--- /dev/null
+/** PURE_IMPORTS_START tslib,_.._Subject,_.._Subscriber,_.._Observable,_.._Subscription,_.._ReplaySubject PURE_IMPORTS_END */
+import * as tslib_1 from "tslib";
+import { Subject, AnonymousSubject } from '../../Subject';
+import { Subscriber } from '../../Subscriber';
+import { Observable } from '../../Observable';
+import { Subscription } from '../../Subscription';
+import { ReplaySubject } from '../../ReplaySubject';
+var DEFAULT_WEBSOCKET_CONFIG = {
+ url: '',
+ deserializer: function (e) { return JSON.parse(e.data); },
+ serializer: function (value) { return JSON.stringify(value); },
+};
+var WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT = 'WebSocketSubject.error must be called with an object with an error code, and an optional reason: { code: number, reason: string }';
+var WebSocketSubject = /*@__PURE__*/ (function (_super) {
+ tslib_1.__extends(WebSocketSubject, _super);
+ function WebSocketSubject(urlConfigOrSource, destination) {
+ var _this = _super.call(this) || this;
+ if (urlConfigOrSource instanceof Observable) {
+ _this.destination = destination;
+ _this.source = urlConfigOrSource;
+ }
+ else {
+ var config = _this._config = tslib_1.__assign({}, DEFAULT_WEBSOCKET_CONFIG);
+ _this._output = new Subject();
+ if (typeof urlConfigOrSource === 'string') {
+ config.url = urlConfigOrSource;
+ }
+ else {
+ for (var key in urlConfigOrSource) {
+ if (urlConfigOrSource.hasOwnProperty(key)) {
+ config[key] = urlConfigOrSource[key];
+ }
+ }
+ }
+ if (!config.WebSocketCtor && WebSocket) {
+ config.WebSocketCtor = WebSocket;
+ }
+ else if (!config.WebSocketCtor) {
+ throw new Error('no WebSocket constructor can be found');
+ }
+ _this.destination = new ReplaySubject();
+ }
+ return _this;
+ }
+ WebSocketSubject.prototype.lift = function (operator) {
+ var sock = new WebSocketSubject(this._config, this.destination);
+ sock.operator = operator;
+ sock.source = this;
+ return sock;
+ };
+ WebSocketSubject.prototype._resetState = function () {
+ this._socket = null;
+ if (!this.source) {
+ this.destination = new ReplaySubject();
+ }
+ this._output = new Subject();
+ };
+ WebSocketSubject.prototype.multiplex = function (subMsg, unsubMsg, messageFilter) {
+ var self = this;
+ return new Observable(function (observer) {
+ try {
+ self.next(subMsg());
+ }
+ catch (err) {
+ observer.error(err);
+ }
+ var subscription = self.subscribe(function (x) {
+ try {
+ if (messageFilter(x)) {
+ observer.next(x);
+ }
+ }
+ catch (err) {
+ observer.error(err);
+ }
+ }, function (err) { return observer.error(err); }, function () { return observer.complete(); });
+ return function () {
+ try {
+ self.next(unsubMsg());
+ }
+ catch (err) {
+ observer.error(err);
+ }
+ subscription.unsubscribe();
+ };
+ });
+ };
+ WebSocketSubject.prototype._connectSocket = function () {
+ var _this = this;
+ var _a = this._config, WebSocketCtor = _a.WebSocketCtor, protocol = _a.protocol, url = _a.url, binaryType = _a.binaryType;
+ var observer = this._output;
+ var socket = null;
+ try {
+ socket = protocol ?
+ new WebSocketCtor(url, protocol) :
+ new WebSocketCtor(url);
+ this._socket = socket;
+ if (binaryType) {
+ this._socket.binaryType = binaryType;
+ }
+ }
+ catch (e) {
+ observer.error(e);
+ return;
+ }
+ var subscription = new Subscription(function () {
+ _this._socket = null;
+ if (socket && socket.readyState === 1) {
+ socket.close();
+ }
+ });
+ socket.onopen = function (e) {
+ var _socket = _this._socket;
+ if (!_socket) {
+ socket.close();
+ _this._resetState();
+ return;
+ }
+ var openObserver = _this._config.openObserver;
+ if (openObserver) {
+ openObserver.next(e);
+ }
+ var queue = _this.destination;
+ _this.destination = Subscriber.create(function (x) {
+ if (socket.readyState === 1) {
+ try {
+ var serializer = _this._config.serializer;
+ socket.send(serializer(x));
+ }
+ catch (e) {
+ _this.destination.error(e);
+ }
+ }
+ }, function (e) {
+ var closingObserver = _this._config.closingObserver;
+ if (closingObserver) {
+ closingObserver.next(undefined);
+ }
+ if (e && e.code) {
+ socket.close(e.code, e.reason);
+ }
+ else {
+ observer.error(new TypeError(WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT));
+ }
+ _this._resetState();
+ }, function () {
+ var closingObserver = _this._config.closingObserver;
+ if (closingObserver) {
+ closingObserver.next(undefined);
+ }
+ socket.close();
+ _this._resetState();
+ });
+ if (queue && queue instanceof ReplaySubject) {
+ subscription.add(queue.subscribe(_this.destination));
+ }
+ };
+ socket.onerror = function (e) {
+ _this._resetState();
+ observer.error(e);
+ };
+ socket.onclose = function (e) {
+ _this._resetState();
+ var closeObserver = _this._config.closeObserver;
+ if (closeObserver) {
+ closeObserver.next(e);
+ }
+ if (e.wasClean) {
+ observer.complete();
+ }
+ else {
+ observer.error(e);
+ }
+ };
+ socket.onmessage = function (e) {
+ try {
+ var deserializer = _this._config.deserializer;
+ observer.next(deserializer(e));
+ }
+ catch (err) {
+ observer.error(err);
+ }
+ };
+ };
+ WebSocketSubject.prototype._subscribe = function (subscriber) {
+ var _this = this;
+ var source = this.source;
+ if (source) {
+ return source.subscribe(subscriber);
+ }
+ if (!this._socket) {
+ this._connectSocket();
+ }
+ this._output.subscribe(subscriber);
+ subscriber.add(function () {
+ var _socket = _this._socket;
+ if (_this._output.observers.length === 0) {
+ if (_socket && _socket.readyState === 1) {
+ _socket.close();
+ }
+ _this._resetState();
+ }
+ });
+ return subscriber;
+ };
+ WebSocketSubject.prototype.unsubscribe = function () {
+ var _socket = this._socket;
+ if (_socket && _socket.readyState === 1) {
+ _socket.close();
+ }
+ this._resetState();
+ _super.prototype.unsubscribe.call(this);
+ };
+ return WebSocketSubject;
+}(AnonymousSubject));
+export { WebSocketSubject };
+//# sourceMappingURL=WebSocketSubject.js.map
projects / dotfiles / .git / blobdiff