Nimble Polyglot Microcosm

    @slite/reconnecting-websocket
    TypeScript icon, indicating that this package has built-in type declarations

    4.4.1 • Public • Published

    Slite's fork of Reconnecting WebSocket

    This is the same as https://github.com/pladaria/reconnecting-websocket but with https://github.com/pladaria/reconnecting-websocket/pull/156

    WebSocket that will automatically reconnect if the connection is closed.

    Features

    • WebSocket API compatible (same interface, Level0 and Level2 event model)
    • Fully configurable
    • Multi-platform (Web, ServiceWorkers, Node.js, React Native)
    • Dependency free (does not depend on Window, DOM or any EventEmitter library)
    • Handle connection timeouts
    • Allows changing server URL between reconnections
    • Buffering. Will send accumulated messages on open
    • Multiple builds available (see dist folder)
    • Debug mode

    Install

    npm install --save reconnecting-websocket

    Usage

    Compatible with WebSocket Browser API

    So this documentation should be valid: MDN WebSocket API.

    Ping me if you find any problems. Or, even better, write a test for your case and make a pull request :)

    Simple usage

    import ReconnectingWebSocket from 'reconnecting-websocket';
    
    const rws = new ReconnectingWebSocket('ws://my.site.com');
    
    rws.addEventListener('open', () => {
        rws.send('hello!');
    });

    Update URL

    The url parameter will be resolved before connecting, possible types:

    • string
    • () => string
    • () => Promise<string>
    import ReconnectingWebSocket from 'reconnecting-websocket';
    
    const urls = ['ws://my.site.com', 'ws://your.site.com', 'ws://their.site.com'];
    let urlIndex = 0;
    
    // round robin url provider
    const urlProvider = () => urls[urlIndex++ % urls.length];
    
    const rws = new ReconnectingWebSocket(urlProvider);
    import ReconnectingWebSocket from 'reconnecting-websocket';
    
    // async url provider
    const urlProvider = async () => {
        const token = await getSessionToken();
        return `wss://my.site.com/${token}`;
    };
    
    const rws = new ReconnectingWebSocket(urlProvider);

    Options

    Sample with custom options

    import ReconnectingWebSocket from 'reconnecting-websocket';
    import WS from 'ws';
    
    const options = {
        WebSocket: WS, // custom WebSocket constructor
        connectionTimeout: 1000,
        maxRetries: 10,
    };
    const rws = new ReconnectingWebSocket('ws://my.site.com', [], options);

    Available options

    type Options = {
        WebSocket?: any; // WebSocket constructor, if none provided, defaults to global WebSocket
        maxReconnectionDelay?: number; // max delay in ms between reconnections
        minReconnectionDelay?: number; // min delay in ms between reconnections
        reconnectionDelayGrowFactor?: number; // how fast the reconnection delay grows
        minUptime?: number; // min time in ms to consider connection as stable
        connectionTimeout?: number; // retry connect if not connected after this time, in ms
        maxRetries?: number; // maximum number of retries
        maxEnqueuedMessages?: number; // maximum number of messages to buffer until reconnection
        startClosed?: boolean; // start websocket in CLOSED state, call `.reconnect()` to connect
        retryURL: boolean; // retry URL provider request if it fails (it follows the same logic as WebSocket retries)
        debug?: boolean; // enables debug output
    };

    Default values

    WebSocket: undefined,
    maxReconnectionDelay: 10000,
    minReconnectionDelay: 1000 + Math.random() * 4000,
    reconnectionDelayGrowFactor: 1.3,
    minUptime: 5000,
    connectionTimeout: 4000,
    maxRetries: Infinity,
    maxEnqueuedMessages: Infinity,
    startClosed: false,
    retryURL: false,
    debug: false,

    API

    Methods

    constructor(url: UrlProvider, protocols?: string | string[], options?: Options)
    
    close(code?: number, reason?: string)
    reconnect(code?: number, reason?: string)
    
    send(data: string | ArrayBuffer | Blob | ArrayBufferView)
    
    addEventListener(type: 'open' | 'close' | 'message' | 'error', listener: EventListener)
    removeEventListener(type:  'open' | 'close' | 'message' | 'error', listener: EventListener)

    Attributes

    More info

    binaryType: string;
    bufferedAmount: number;
    extensions: string;
    onclose: EventListener;
    onerror: EventListener;
    onmessage: EventListener;
    onopen: EventListener;
    protocol: string;
    readyState: number;
    url: string;
    retryCount: number;

    Constants

    CONNECTING 0 The connection is not yet open.
    OPEN       1 The connection is open and ready to communicate.
    CLOSING    2 The connection is in the process of closing.
    CLOSED     3 The connection is closed or couldn't be opened.
    

    Contributing

    Read here

    License

    MIT

    Install

    npm i @slite/reconnecting-websocket

    DownloadsWeekly Downloads

    10

    Version

    4.4.1

    License

    MIT

    Unpacked Size

    141 kB

    Total Files

    11

    Last publish

    Collaborators

    • dqms
    • accounts-dev-slite
    • calyhre
    • arnaudrinquin
    • prenaudin
    • shahor
    • antoineduban
    • julienr2
    • guillaumemorin
    • christophepas
    • antoinelyset
    • d34thwings
    • jasonphillips
    • bitphinix
    • agix
    • alisonsayarath
    • emanuelpinho