protomux-rpc-web/dist/index.js

import EventEmitter from "events";
// @ts-ignore
import Protomux from "protomux";
// @ts-ignore
import c from "compact-encoding";
// @ts-ignore
import bitfield from "compact-encoding-bitfield";
// @ts-ignore
import bits from "bits-to-bytes";
export default class ProtomuxRPC extends EventEmitter {
    _id;
    _ending;
    _error;
    _responding;
    _requests;
    _defaultValueEncoding;
    _responders;
    _channel;
    _request;
    _response;
    constructor(stream, options = {}) {
        super();
        this._mux = Protomux.from(stream);
        this._defaultValueEncoding = options?.valueEncoding;
        this._id = 1;
        this._ending = false;
        this._responding = 0;
        this._requests = new Map();
        this._responders = new Map();
        this._ready = this._init(options);
    }
    _mux;
    get mux() {
        return this._mux;
    }
    _ready;
    get ready() {
        return this._ready;
    }
    get closed() {
        return this._channel.closed;
    }
    get stream() {
        return this._mux.stream;
    }
    async _init(options) {
        this._channel = await this._mux.createChannel({
            protocol: "protomux-rpc",
            id: options?.id,
            handshake: options?.handshake
                ? options?.handshakeEncoding || c.raw
                : null,
            onopen: this._onopen.bind(this),
            onclose: this._onclose.bind(this),
            ondestroy: this._ondestroy.bind(this),
        });
        if (this._channel === null)
            throw new Error("duplicate channel");
        this._request = await this._channel.addMessage({
            encoding: request,
            onmessage: this._onrequest.bind(this),
        });
        this._response = await this._channel.addMessage({
            encoding: response,
            onmessage: this._onresponse.bind(this),
        });
        this._channel.open(options?.handshake);
        await this._channel.ready;
    }
    _onopen(handshake) {
        this.emit("open", handshake);
    }
    _onclose() {
        const err = this._error || new Error("channel closed");
        for (const request of this._requests.values()) {
            request.reject(err);
        }
        this._requests.clear();
        this._responders.clear();
        this.emit("close");
    }
    _ondestroy() {
        this.emit("destroy");
    }
    async _onrequest({ id, method, value, }) {
        let error = null;
        const responder = this._responders.get(method);
        if (responder === undefined)
            error = `unknown method '${method}'`;
        else {
            const { valueEncoding = this._defaultValueEncoding, requestEncoding = valueEncoding, responseEncoding = valueEncoding, } = responder.options;
            if (requestEncoding)
                value = c.decode(requestEncoding, value);
            this._responding++;
            try {
                value = await responder.handler(value);
            }
            catch (err) {
                error = err.message;
            }
            this._responding--;
            if (!error && responseEncoding && id) {
                value = c.encode(responseEncoding, value);
            }
        }
        if (id)
            this._response.send({ id, error, value });
        this._endMaybe();
    }
    _onresponse({ id, error, value }) {
        if (id === 0)
            return;
        const request = this._requests.get(id);
        if (request === undefined)
            return;
        this._requests.delete(id);
        if (error)
            request.reject(new Error(error));
        else {
            const { valueEncoding = this._defaultValueEncoding, responseEncoding = valueEncoding, } = request.options;
            if (responseEncoding)
                value = c.decode(responseEncoding, value);
            request.resolve(value);
        }
        this._endMaybe();
    }
    respond(method, options, handler) {
        if (typeof options === "function") {
            handler = options;
            options = {};
        }
        this._responders.set(method, { options, handler });
        return this;
    }
    unrespond(method) {
        this._responders.delete(method);
        return this;
    }
    async request(method, value, options = {}) {
        if (this.closed)
            throw new Error("channel closed");
        const { valueEncoding = this._defaultValueEncoding, requestEncoding = valueEncoding, } = options;
        if (requestEncoding)
            value = c.encode(requestEncoding, value);
        const id = this._id++;
        this._request.send({ id, method, value });
        return new Promise((resolve, reject) => {
            this._requests.set(id, { options, resolve, reject });
        });
    }
    event(method, value, options = {}) {
        if (this.closed)
            throw new Error("channel closed");
        const { valueEncoding = this._defaultValueEncoding, requestEncoding = valueEncoding, } = options;
        if (requestEncoding)
            value = c.encode(requestEncoding, value);
        this._request.send({ id: 0, method, value });
    }
    cork() {
        this._channel.cork();
    }
    uncork() {
        this._channel.uncork();
    }
    async end() {
        this._ending = true;
        this._endMaybe();
        await EventEmitter.once(this, "close");
    }
    _endMaybe() {
        if (this._ending && this._responding === 0 && this._requests.size === 0) {
            this._channel.close();
        }
    }
    destroy(err) {
        this._error = err || new Error("channel destroyed");
        this._channel.close();
    }
}
const request = {
    preencode(state, m) {
        c.uint.preencode(state, m.id);
        c.string.preencode(state, m.method);
        c.raw.preencode(state, m.value);
    },
    encode(state, m) {
        c.uint.encode(state, m.id);
        c.string.encode(state, m.method);
        c.raw.encode(state, m.value);
    },
    decode(state) {
        return {
            id: c.uint.decode(state),
            method: c.string.decode(state),
            value: c.raw.decode(state),
        };
    },
};
const flags = bitfield(1);
const response = {
    preencode(state, m) {
        flags.preencode(state);
        c.uint.preencode(state, m.id);
        if (m.error)
            c.string.preencode(state, m.error);
        else
            c.raw.preencode(state, m.value);
    },
    encode(state, m) {
        flags.encode(state, bits.of(m.error));
        c.uint.encode(state, m.id);
        if (m.error)
            c.string.encode(state, m.error);
        else
            c.raw.encode(state, m.value);
    },
    decode(state) {
        const [error] = bits.iterator(flags.decode(state));
        return {
            id: c.uint.decode(state),
            error: error ? c.string.decode(state) : null,
            value: !error ? c.raw.decode(state) : null,
        };
    },
};