landstrasse/build/module/transport.js

Strongly typed WAMP Client for browsers

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { ETransportEventType } from './types/Transport';
import SerializationError from './error/SerializationError';
class WebSocketTransport {
    constructor(serializer) {
        Object.defineProperty(this, "serializer", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: serializer
        });
        Object.defineProperty(this, "webSocket", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: null
        });
        Object.defineProperty(this, "callback", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: null
        });
    }
    get isOpen() {
        return !!this.webSocket;
    }
    open(endpoint, cb) {
        if (this.webSocket) {
            cb({ type: ETransportEventType.ERROR, error: 'Transport already opened!' });
            return;
        }
        this.webSocket = new WebSocket(endpoint, this.serializer.protocolId);
        this.callback = cb;
        if (this.serializer.isBinary) {
            this.webSocket.binaryType = 'arraybuffer';
        }
        this.webSocket.onopen = () => {
            cb({ type: ETransportEventType.OPEN });
        };
        this.webSocket.onmessage = (ev) => {
            try {
                const message = this.serializer.unserialize(ev.data);
                cb({ type: ETransportEventType.MESSAGE, message });
            }
            catch (error) {
                cb({ type: ETransportEventType.ERROR, error });
            }
        };
        this.webSocket.onclose = (ev) => {
            this.webSocket.onclose = null;
            this.webSocket.onerror = null;
            this.callback = null;
            this.webSocket = null;
            cb({
                type: ETransportEventType.CLOSE,
                code: ev.code,
                reason: ev.reason,
                message: 'Received close event.',
                wasClean: ev.wasClean,
            });
        };
        this.webSocket.onerror = (err) => {
            this.webSocket.onclose = null;
            this.webSocket.onerror = null;
            this.callback = null;
            this.webSocket = null;
            cb({
                type: ETransportEventType.CRITICAL_ERROR,
                error: `Transport critical error${err.error ? `: ${err.error}` : ''}.`,
            });
        };
    }
    close(code, reason, message = '') {
        if (!this.webSocket || !this.callback) {
            return;
        }
        this.webSocket.onclose = null;
        this.webSocket.onerror = null;
        this.webSocket.close(code, reason);
        this.callback({
            type: ETransportEventType.CLOSE,
            code,
            reason,
            message,
            wasClean: true,
        });
        this.callback = null;
        this.webSocket = null;
    }
    send(msg) {
        return __awaiter(this, void 0, void 0, function* () {
            let payload;
            try {
                payload = this.serializer.serialize(msg);
            }
            catch (err) {
                throw new SerializationError(err);
            }
            return this.webSocket.send(payload);
        });
    }
}
export default WebSocketTransport;
//# sourceMappingURL=transport.js.map