engine.io-client

method doPoll

doPoll: () => void;

method doWrite

doWrite: (data: string, callback: () => void) => void;

method createSocket

createSocket: (
    uri: string,
    protocols: string | string[] | undefined,
    opts: Record<string, any>
) => any;

method doWrite

doWrite: (packet: Packet, data: RawData) => void;

method request

request: (opts?: Record<string, any>) => Request;

constructor

constructor();

• Socket constructor.

  Parameter uri

  uri or options

  Parameter opts

  options

constructor

constructor(uri: string, opts?: SocketOptions);

constructor

constructor(opts: SocketOptions);

property binaryType

binaryType: BinaryType;

property id

id: string;

property opts

protected readonly opts: SocketOptions;

property priorWebsocketSuccess

static priorWebsocketSuccess: boolean;

property protocol

static protocol: number;

property readyState

readyState: SocketState;

property setTimeoutFn

protected setTimeoutFn: (
    handler: TimerHandler,
    timeout?: number,
    ...arguments: any[]
) => number;

property transport

transport: Transport;

property transports

protected readonly transports: TransportName[];

property upgrading

protected upgrading: boolean;

property writeBuffer

writeBuffer: Packet[];

method close

close: () => this;

• Closes the connection.

method createTransport

protected createTransport: (name: string) => Transport;

• Creates transport of the given type.

  Parameter name

  transport name {Transport}

method flush

protected flush: () => void;

• Flush write buffers.

method onHandshake

protected onHandshake: (data: HandshakeData) => void;

• Called upon handshake completion.

  Parameter data

  handshake obj

method onOpen

protected onOpen: () => void;

• Called when connection is deemed open.

method send

send: (msg: RawData, options?: WriteOptions, fn?: () => void) => this;

• Sends a message. Alias of Socket#write.

  Parameter msg

  message.

  Parameter

  {Object} options.

  Parameter fn

  callback function. {Socket} for chaining.

method setTransport

protected setTransport: (transport: Transport) => void;

• Sets the current transport. Disables the existing one (if any).

method write

write: (msg: RawData, options?: WriteOptions, fn?: () => void) => this;

• Sends a message.

  Parameter msg

  message.

  Parameter

  {Object} options.

  Parameter fn

  callback function. {Socket} for chaining.

constructor

constructor(opts: any);

• Transport abstract constructor.

  Parameter opts

  options

property name

readonly name: string;

• The name of the transport

property opts

protected opts: SocketOptions;

property query

query: Record<string, string>;

property readyState

protected readyState: TransportState;

property setTimeoutFn

protected setTimeoutFn: (
    handler: TimerHandler,
    timeout?: number,
    ...arguments: any[]
) => number;

property socket

protected socket: Socket;

property supportsBinary

protected supportsBinary: boolean;

property writable

writable: boolean;

method close

close: () => this;

• Closes the transport.

method createUri

protected createUri: (schema: string, query?: Record<string, unknown>) => string;

method doClose

protected abstract doClose: () => any;

method doOpen

protected abstract doOpen: () => any;

method onClose

protected onClose: (details?: CloseDetails) => void;

• Called upon close.

method onData

protected onData: (data: RawData) => void;

• Called with data.

  Parameter data

method onError

protected onError: (reason: string, description: any, context?: any) => this;

• Emits an error.

  Parameter reason

  Parameter description

  Parameter context

  the error context {Transport} for chaining

method onOpen

protected onOpen: () => void;

• Called upon open

method onPacket

protected onPacket: (packet: Packet) => void;

• Called with a decoded packet.

method open

open: () => this;

• Opens the transport.

method pause

pause: (onPause: () => void) => void;

• Pauses the transport, in order not to lose packets during an upgrade.

  Parameter onPause

method send

send: (packets: any) => void;

• Sends multiple packets.

  Parameter packets

method write

protected abstract write: (packets: Packet[]) => any;

constructor

constructor(reason: string, description: any, context: any);

property context

readonly context: any;

property description

readonly description: any;

property type

readonly type: string;

method createSocket

createSocket: (
    uri: string,
    protocols: string | string[] | undefined,
    opts: Record<string, any>
) => any;

method doWrite

doWrite: (_packet: Packet, data: RawData) => void;

property name

readonly name: string;

method doClose

protected doClose: () => void;

method doOpen

protected doOpen: () => this;

method write

protected write: (packets: Packet[]) => void;

constructor

constructor(opts: any);

method request

request: (opts?: Record<string, any>) => Request;

property expires

expires?: Date;

property name

name: string;

property value

value: string;

property maxPayload

maxPayload: number;

property pingInterval

pingInterval: number;

property pingTimeout

pingTimeout: number;

property sid

sid: string;

property upgrades

upgrades: string[];

property addTrailingSlash

addTrailingSlash?: boolean;

• Whether we should add a trailing slash to the request path. true

property agent

agent?: string | boolean;

• http.Agent to use, defaults to false (NodeJS only)

  Note: the type should be "undefined | http.Agent | https.Agent | false", but this would break browser-only clients.

  See Also

  • https://nodejs.org/api/http.html#httprequestoptions-callback

property autoUnref

autoUnref?: boolean;

• Whether the heartbeat timer should be unref'ed, in order not to keep the Node.js event loop active.

  See Also

  • https://nodejs.org/api/timers.html#timeoutunref false

property ca

ca?: string | string[];

• (SSL) An authority certificate or array of authority certificates to check the remote host against.. Can be used in Node.js client environment to manually specify certificate information.

property cert

cert?: string;

• (SSL) Public x509 certificate to use. Can be used in Node.js client environment to manually specify certificate information.

property ciphers

ciphers?: string;

• (SSL) A string describing the ciphers to use or exclude. Consult the [cipher format list] (http://www.openssl.org/docs/apps/ciphers.html#CIPHER_LIST_FORMAT) for details on the format.. Can be used in Node.js client environment to manually specify certificate information.

property closeOnBeforeunload

closeOnBeforeunload?: boolean;

• Whether to automatically close the connection whenever the beforeunload event is received. false

property extraHeaders

extraHeaders?: {
    [header: string]: string;
};

• Headers that will be passed for each request to the server (via xhr-polling and via websockets). These values then can be used during handshake or for special proxies.

property forceBase64

forceBase64?: boolean;

• Forces base 64 encoding for polling transport even when XHR2 responseType is available and WebSocket even if the used standard supports binary.

property host

host?: string;

• The host that we're connecting to. Set from the URI passed when connecting

property hostname

hostname?: string;

• The hostname for our connection. Set from the URI passed when connecting

property key

key?: string;

• (SSL) Private key to use for SSL. Can be used in Node.js client environment to manually specify certificate information.

property passphrase

passphrase?: string;

• (SSL) A string or passphrase for the private key or pfx. Can be used in Node.js client environment to manually specify certificate information.

property path

path?: string;

• The path to get our client file from, in the case of the server serving it '/engine.io'

property perMessageDeflate

perMessageDeflate?: {
    threshold: number;
};

• parameters of the WebSocket permessage-deflate extension (see ws module api docs). Set to false to disable. false

property pfx

pfx?: string;

• (SSL) Certificate, Private key and CA certificates to use for SSL. Can be used in Node.js client environment to manually specify certificate information.

property port

port?: string | number;

• The port for our connection. Set from the URI passed when connecting

property protocols

protocols?: string | string[];

• Either a single protocol string or an array of protocol strings. These strings are used to indicate sub-protocols, so that a single server can implement multiple WebSocket sub-protocols (for example, you might want one server to be able to handle different types of interactions depending on the specified protocol) []

property query

query?: {
    [key: string]: any;
};

• Any query parameters in our uri. Set from the URI passed when connecting

property rejectUnauthorized

rejectUnauthorized?: boolean;

• (SSL) If true, the server certificate is verified against the list of supplied CAs. An 'error' event is emitted if verification fails. Verification happens at the connection level, before the HTTP request is sent. Can be used in Node.js client environment to manually specify certificate information.

property rememberUpgrade

rememberUpgrade?: boolean;

• If true and if the previous websocket connection to the server succeeded, the connection attempt will bypass the normal upgrade process and will initially try websocket. A connection attempt following a transport error will use the normal upgrade process. It is recommended you turn this on only when using SSL/TLS connections, or if you know that your network does not block websockets. false

property requestTimeout

requestTimeout?: number;

• Timeout for xhr-polling requests in milliseconds (0) (only for polling transport)

property secure

secure?: boolean;

• If this is a secure connection. Set from the URI passed when connecting

property timestampParam

timestampParam?: string;

• The param name to use as our timestamp key 't'

property timestampRequests

timestampRequests?: boolean;

• Whether to add the timestamp with each transport request. Note: this is ignored if the browser is IE or Android, in which case requests are always stamped false

property transportImplementations

transportImplementations?: TransportCtor[];

• A list of low-level transport implementations to use instead of the defaults.

  The order of the array determines the order in which transports are tried.

  Example 1

  import { Fetch, WebSocket } from "engine.io-client";

  const socket = new Socket({ transportImplementations: [Fetch, WebSocket] });

property transportOptions

transportOptions?: Object;

• Transport options for Node.js client (headers etc)

property transports

transports?: TransportName[] | TransportCtor[];

• A list of transports to try (in order). Engine.io always attempts to connect directly with the first one, provided the feature detection test for it passes.

  ['polling','websocket', 'webtransport']

property tryAllTransports

tryAllTransports?: boolean;

• Whether all the transports should be tested, instead of just the first one.

  If set to true, the client will first try to connect with HTTP long-polling, and then with WebSocket in case of failure, and finally with WebTransport if the previous attempts have failed.

  If set to false (default), if the connection with HTTP long-polling fails, then the client will not test the other transports and will abort the connection.

  false

property upgrade

upgrade?: boolean;

• Whether the client should try to upgrade the transport from long-polling to something better. true

property useNativeTimers

useNativeTimers?: boolean;

• Whether to always use the native timeouts. This allows the client to reconnect when the native timeout functions are overridden, such as when mock clocks are installed. false

property withCredentials

withCredentials?: boolean;

• Whether to include credentials (cookies, authorization headers, TLS client certificates, etc.) with cross-origin XHR polling requests false

property close

close: (reason: string, description?: CloseDetails | Error) => void;

property data

data: (data: RawData) => void;

property drain

drain: () => void;

property error

error: (err: string | Error) => void;

property flush

flush: () => void;

property handshake

handshake: (data: HandshakeData) => void;

property heartbeat

heartbeat: () => void;

property message

message: (data: RawData) => void;

property open

open: () => void;

property packet

packet: (packet: Packet) => void;

property packetCreate

packetCreate: (packet: Packet) => void;

property ping

ping: () => void;

property pong

pong: () => void;

property upgrade

upgrade: (transport: Transport) => void;

property upgradeError

upgradeError: (err: Error) => void;

property upgrading

upgrading: (transport: Transport) => void;

property close

close: (details?: CloseDetails) => void;

property drain

drain: () => void;

property error

error: (err: TransportError) => void;

property open

open: () => void;

property packet

packet: (packet: Packet) => void;

property poll

poll: () => void;

property pollComplete

pollComplete: () => void;

property compress

compress?: boolean;