vertx3-eventbus-rx-client/dist/event-bus.js

RxJS powered Event Bus client for Vert.x 3

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
require("rxjs/add/observable/bindNodeCallback");
require("rxjs/add/observable/defer");
require("rxjs/add/observable/empty");
require("rxjs/add/observable/fromEvent");
require("rxjs/add/observable/fromEventPattern");
require("rxjs/add/observable/merge");
require("rxjs/add/operator/first");
require("rxjs/add/operator/map");
require("rxjs/add/operator/mapTo");
require("rxjs/add/operator/startWith");
require("rxjs/add/operator/takeUntil");
var Observable_1 = require("rxjs/Observable");
var EB = require("vertx3-eventbus-client");
var state_1 = require("./model/state");
var EventBus = (function () {
    function EventBus(delegate) {
        var _this = this;
        this._closeEvent = null;
        this._appendReplyFns = function (msg) {
            var replyAddress = msg.replyAddress;
            if (!replyAddress) {
                return msg;
            }
            return __assign({}, msg, { reply: function (message, headers) {
                    _this.send(replyAddress, message, headers);
                }, rxReply: function (message, headers) {
                    return _this.rxSend(replyAddress, message, headers);
                } });
        };
        this.delegate = delegate;
        this._stateClosedEvent$.subscribe(function (event) { return _this._closeEvent = event || null; });
        this.state$ = Observable_1.Observable.defer(function () {
            return Observable_1.Observable
                .merge(_this._stateOpenEvent$.mapTo(state_1.State.OPEN).takeUntil(_this._stateClosedEvent$), _this._stateClosedEvent$.mapTo(state_1.State.CLOSED))
                .startWith(delegate.state);
        });
    }
    EventBus.create = function (url, options) {
        var delegate = new EB(url, options);
        return new EventBus(delegate);
    };
    Object.defineProperty(EventBus.prototype, "defaultHeaders", {
        get: function () {
            return this.delegate.defaultHeaders;
        },
        set: function (headers) {
            this.delegate.defaultHeaders = headers;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(EventBus.prototype, "state", {
        get: function () {
            return this.delegate.state;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(EventBus.prototype, "closeEvent", {
        get: function () {
            return this._closeEvent;
        },
        enumerable: true,
        configurable: true
    });
    EventBus.prototype.send = function (address, message, headers) {
        this.delegate.send(address, message, headers);
    };
    EventBus.prototype.rxSend = function (address, message, headers) {
        var generatorFn = Observable_1.Observable.bindNodeCallback(this.delegate.send.bind(this.delegate));
        return generatorFn(address, message, headers)
            .map(this._appendReplyFns)
            .takeUntil(this._stateClosedEvent$);
    };
    EventBus.prototype.publish = function (address, message, headers) {
        this.delegate.publish(address, message, headers);
    };
    EventBus.prototype.rxConsumer = function (address, headers) {
        var _this = this;
        return Observable_1.Observable.fromEventPattern(function (handler) {
            _this.delegate.registerHandler(address, headers, handler);
        }, function (handler) {
            if (_this.state === state_1.State.OPEN) {
                _this.delegate.unregisterHandler(address, headers, handler);
            }
        }, function (err, msg) {
            if (err) {
                throw err;
            }
            return msg;
        })
            .map(this._appendReplyFns)
            .takeUntil(this._stateClosedEvent$);
    };
    EventBus.prototype.close = function () {
        this.delegate.close();
    };
    EventBus.prototype.setPingEnabled = function (enabled) {
        this.delegate.pingEnabled(enabled);
    };
    Object.defineProperty(EventBus.prototype, "_stateOpenEvent$", {
        get: function () {
            if (this.state !== state_1.State.CONNECTING) {
                return Observable_1.Observable.empty();
            }
            return Observable_1.Observable
                .fromEvent(this.delegate.sockJSConn, 'open')
                .first();
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(EventBus.prototype, "_stateClosedEvent$", {
        get: function () {
            if (this.state === state_1.State.CLOSED) {
                return Observable_1.Observable.empty();
            }
            return Observable_1.Observable
                .fromEvent(this.delegate.sockJSConn, 'close')
                .first();
        },
        enumerable: true,
        configurable: true
    });
    return EventBus;
}());
exports.EventBus = EventBus;
//# sourceMappingURL=event-bus.js.map