landstrasse/build/module/processor/publisher.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 AbstractProcessor from './AbstractProcessor';
import PendingMap from '../util/map';
import { LogLevel } from '../util/logger';
import { EWampMessageID } from '../types/messages/MessageTypes';
class Publisher extends AbstractProcessor {
    constructor() {
        super(...arguments);
        Object.defineProperty(this, "_publicationRequests", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new PendingMap(EWampMessageID.PUBLISH, EWampMessageID.PUBLISHED)
        });
    }
    static getFeatures() {
        return {
            publisher: {
                features: {
                    subscriber_blackwhite_listing: true,
                    publisher_exclusion: true,
                    publisher_identification: true,
                    sharded_subscription: true,
                },
            },
        };
    }
    publish(topic, args, kwArgs, options) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this._closed) {
                throw new Error('Publisher already closed.');
            }
            const requestId = this.idGenerators.session.id();
            const message = [EWampMessageID.PUBLISH, requestId, options || {}, topic, args || [], kwArgs || {}];
            const request = this._publicationRequests.add(requestId);
            this.logger.log(LogLevel.DEBUG, `Publishing \`${topic}\` (request id: ${requestId}).`, args, kwArgs, options);
            try {
                yield this.sender(message);
            }
            catch (err) {
                this._publicationRequests.reject(requestId, err);
                throw err;
            }
            if (!(options === null || options === void 0 ? void 0 : options.acknowledge)) {
                return Promise.resolve(undefined);
            }
            const [, , publicationId] = yield request;
            return publicationId;
        });
    }
    //
    // - Handlers.
    //
    onMessage(msg) {
        const [handled, success, error] = this._publicationRequests.handle(msg);
        if (handled && !success) {
            this.violator(error);
        }
        return handled;
    }
    onClose() {
        this._publicationRequests.close();
    }
}
export default Publisher;
//# sourceMappingURL=publisher.js.map