@akala/core/dist/esm/network/websocket.js

import { EventEmitter } from "../events/event-emitter.js";
import { IsomorphicBuffer } from "../helpers.js";
import { Deferred } from "../promiseHelpers.js";
import { StatefulSubscription } from "../teardown-manager.js";
/**
 * json-rpc-ws connection
 *
 * @constructor
 * @param {Socket} socket - web socket for this connection
 * @param {Object} parent - parent that controls this connection
 */
export class WebSocketAdapter extends EventEmitter {
    socket;
    constructor(socket) {
        super();
        this.socket = socket;
    }
    pipe(socket) {
        this.on('message', (message) => socket.send(message));
        this.on('close', () => socket.close());
    }
    get open() {
        return this.socket.readyState == WebSocket.OPEN;
    }
    close() {
        const deferred = new Deferred();
        this.socket.addEventListener('close', () => deferred.resolve());
        this.socket.close();
        return deferred;
    }
    send(data) {
        this.socket.send(data instanceof IsomorphicBuffer ? data.toArray() : data);
        return Promise.resolve();
    }
    messageListeners = [];
    off(event, handler) {
        switch (event) {
            case 'message':
                {
                    let listeners = this.messageListeners;
                    if (handler)
                        listeners = listeners.filter(f => f[0] == handler);
                    listeners.forEach(l => this.socket.removeEventListener('message', l[1]));
                }
                break;
            case 'close':
            case 'error':
            case 'open':
                //eslint-disable-next-line @typescript-eslint/no-explicit-any
                this.socket.removeEventListener(event, handler);
                break;
            default:
                throw new Error(`Unsupported event ${String(event)}`);
        }
        return true;
    }
    on(event, handler, options) {
        switch (event) {
            case 'message':
                {
                    const x = function (ev) { return handler.call(this, typeof ev.data === 'string' ? ev.data : IsomorphicBuffer.fromArrayBuffer(ev.data)); };
                    this.messageListeners.push([handler, x]);
                    this.socket.addEventListener('message', x, options);
                    return new StatefulSubscription(() => {
                        this.messageListeners.splice(this.messageListeners.findIndex(x => x[0] === handler), 1);
                        this.socket.removeEventListener('message', x);
                    }).unsubscribe;
                }
            case 'close':
            case 'error':
            case 'open':
                //eslint-disable-next-line @typescript-eslint/no-explicit-any
                this.socket.addEventListener(event, handler);
                return new StatefulSubscription(() => {
                    this.socket.removeEventListener(event, handler);
                }).unsubscribe;
            case Symbol.dispose:
                return super.on(event, handler, options);
            default:
                throw new Error(`Unsupported event ${String(event)}`);
        }
    }
    once(event, handler) {
        switch (event) {
            case 'message':
                return this.on(event, handler, { once: true });
            case 'close':
            case 'error':
            case 'open':
            case Symbol.dispose:
                return this.on(event, handler, { once: true });
            default:
                let x = event;
                throw new Error(`Unsupported event ${x}`);
        }
    }
}
//# sourceMappingURL=websocket.js.map