ij-rpc-client/out/rpc.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Promise = require("bluebird");
class PromiseCallback {
    constructor(resolve, reject) {
        this.resolve = resolve;
        this.reject = reject;
    }
}
class JsonRpc {
    constructor(transport, domains = null) {
        this.transport = transport;
        this.messageIdCounter = 0;
        this.callbacks = new Map();
        this.domains = new Map();
        this.domains = new Map();
        if (domains != null) {
            for (let name of Object.getOwnPropertyNames(domains)) {
                this.domains.set(name, domains[name]);
            }
        }
        transport.messageReceived = this.messageReceived.bind(this);
    }
    registerDomain(name, commands) {
        if (this.domains.has(name)) {
            throw Error("Domain " + name + " is already registered");
        }
        this.domains.set(name, commands);
    }
    send(domain, command, ...params) {
        this.transport.send(-1, domain, command, params);
    }
    call(domain, command, ...params) {
        return new Promise((resolve, reject) => {
            const id = this.messageIdCounter++;
            this.callbacks.set(id, new PromiseCallback(resolve, reject));
            this.transport.send(id, domain, command, params);
        });
    }
    messageReceived(message) {
        if (message.length === 1 || (message.length === 2 && !(typeof message[1] === "string"))) {
            const promiseCallback = this.callbacks.get(message[0]);
            const singletonArray = safeGet(message, 1);
            if (singletonArray == null) {
                promiseCallback.resolve();
            }
            else {
                promiseCallback.resolve(singletonArray[0]);
            }
        }
        else {
            let id;
            let offset;
            if (typeof message[0] === "string") {
                id = -1;
                offset = 0;
            }
            else {
                id = message[0];
                offset = 1;
            }
            const domainName = message[offset];
            if (domainName === "e") {
                console.assert(id != -1);
                console.assert(message.length === 3);
                this.callbacks.get(id).reject(message[2]);
                return;
            }
            const onRejected = id === -1 ? null : (error) => this.transport.sendError(id, error);
            try {
                const object = this.domains.get(domainName);
                if (object == null) {
                    const e = "Cannot find domain " + domainName;
                    console.warn(e);
                    if (onRejected != null) {
                        onRejected(e);
                    }
                    return;
                }
                const method = object[message[offset + 1]];
                const args = safeGet(message, offset + 2);
                const result = (args === null) ? method.call(object) : method.apply(object, args);
                if (id !== -1) {
                    const onFulfilled = (result) => this.transport.sendResult(id, result);
                    if (result instanceof Promise) {
                        result.done(onFulfilled, onRejected);
                    }
                    else {
                        onFulfilled(result);
                    }
                }
            }
            catch (e) {
                console.error(e);
                if (onRejected != null) {
                    onRejected(e);
                }
            }
        }
    }
}
exports.JsonRpc = JsonRpc;
function safeGet(a, index) {
    return index < a.length ? a[index] : null;
}
//# sourceMappingURL=rpc.js.map