| /** PURE_IMPORTS_START .._.._Subject,.._.._Subscriber,.._.._Observable,.._.._Subscription,.._.._util_root,.._.._ReplaySubject,.._.._util_tryCatch,.._.._util_errorObject,.._.._util_assign PURE_IMPORTS_END */ |
| var __extends = (this && this.__extends) || function (d, b) { |
| for (var p in b) |
| if (b.hasOwnProperty(p)) |
| d[p] = b[p]; |
| function __() { this.constructor = d; } |
| d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); |
| }; |
| import { Subject, AnonymousSubject } from '../../Subject'; |
| import { Subscriber } from '../../Subscriber'; |
| import { Observable } from '../../Observable'; |
| import { Subscription } from '../../Subscription'; |
| import { root } from '../../util/root'; |
| import { ReplaySubject } from '../../ReplaySubject'; |
| import { tryCatch } from '../../util/tryCatch'; |
| import { errorObject } from '../../util/errorObject'; |
| import { assign } from '../../util/assign'; |
| /** |
| * We need this JSDoc comment for affecting ESDoc. |
| * @extends {Ignored} |
| * @hide true |
| */ |
| export var WebSocketSubject = /*@__PURE__*/ (/*@__PURE__*/ function (_super) { |
| __extends(WebSocketSubject, _super); |
| function WebSocketSubject(urlConfigOrSource, destination) { |
| if (urlConfigOrSource instanceof Observable) { |
| _super.call(this, destination, urlConfigOrSource); |
| } |
| else { |
| _super.call(this); |
| this.WebSocketCtor = root.WebSocket; |
| this._output = new Subject(); |
| if (typeof urlConfigOrSource === 'string') { |
| this.url = urlConfigOrSource; |
| } |
| else { |
| // WARNING: config object could override important members here. |
| assign(this, urlConfigOrSource); |
| } |
| if (!this.WebSocketCtor) { |
| throw new Error('no WebSocket constructor can be found'); |
| } |
| this.destination = new ReplaySubject(); |
| } |
| } |
| WebSocketSubject.prototype.resultSelector = function (e) { |
| return JSON.parse(e.data); |
| }; |
| /** |
| * Wrapper around the w3c-compatible WebSocket object provided by the browser. |
| * |
| * @example <caption>Wraps browser WebSocket</caption> |
| * |
| * let socket$ = Observable.webSocket('ws://localhost:8081'); |
| * |
| * socket$.subscribe( |
| * (msg) => console.log('message received: ' + msg), |
| * (err) => console.log(err), |
| * () => console.log('complete') |
| * ); |
| * |
| * socket$.next(JSON.stringify({ op: 'hello' })); |
| * |
| * @example <caption>Wraps WebSocket from nodejs-websocket (using node.js)</caption> |
| * |
| * import { w3cwebsocket } from 'websocket'; |
| * |
| * let socket$ = Observable.webSocket({ |
| * url: 'ws://localhost:8081', |
| * WebSocketCtor: w3cwebsocket |
| * }); |
| * |
| * socket$.subscribe( |
| * (msg) => console.log('message received: ' + msg), |
| * (err) => console.log(err), |
| * () => console.log('complete') |
| * ); |
| * |
| * socket$.next(JSON.stringify({ op: 'hello' })); |
| * |
| * @param {string | WebSocketSubjectConfig} urlConfigOrSource the source of the websocket as an url or a structure defining the websocket object |
| * @return {WebSocketSubject} |
| * @static true |
| * @name webSocket |
| * @owner Observable |
| */ |
| WebSocketSubject.create = function (urlConfigOrSource) { |
| return new WebSocketSubject(urlConfigOrSource); |
| }; |
| WebSocketSubject.prototype.lift = function (operator) { |
| var sock = new WebSocketSubject(this, this.destination); |
| sock.operator = operator; |
| return sock; |
| }; |
| WebSocketSubject.prototype._resetState = function () { |
| this.socket = null; |
| if (!this.source) { |
| this.destination = new ReplaySubject(); |
| } |
| this._output = new Subject(); |
| }; |
| // TODO: factor this out to be a proper Operator/Subscriber implementation and eliminate closures |
| WebSocketSubject.prototype.multiplex = function (subMsg, unsubMsg, messageFilter) { |
| var self = this; |
| return new Observable(function (observer) { |
| var result = tryCatch(subMsg)(); |
| if (result === errorObject) { |
| observer.error(errorObject.e); |
| } |
| else { |
| self.next(result); |
| } |
| var subscription = self.subscribe(function (x) { |
| var result = tryCatch(messageFilter)(x); |
| if (result === errorObject) { |
| observer.error(errorObject.e); |
| } |
| else if (result) { |
| observer.next(x); |
| } |
| }, function (err) { return observer.error(err); }, function () { return observer.complete(); }); |
| return function () { |
| var result = tryCatch(unsubMsg)(); |
| if (result === errorObject) { |
| observer.error(errorObject.e); |
| } |
| else { |
| self.next(result); |
| } |
| subscription.unsubscribe(); |
| }; |
| }); |
| }; |
| WebSocketSubject.prototype._connectSocket = function () { |
| var _this = this; |
| var WebSocketCtor = this.WebSocketCtor; |
| var observer = this._output; |
| var socket = null; |
| try { |
| socket = this.protocol ? |
| new WebSocketCtor(this.url, this.protocol) : |
| new WebSocketCtor(this.url); |
| this.socket = socket; |
| if (this.binaryType) { |
| this.socket.binaryType = this.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 openObserver = _this.openObserver; |
| if (openObserver) { |
| openObserver.next(e); |
| } |
| var queue = _this.destination; |
| _this.destination = Subscriber.create(function (x) { return socket.readyState === 1 && socket.send(x); }, function (e) { |
| var closingObserver = _this.closingObserver; |
| if (closingObserver) { |
| closingObserver.next(undefined); |
| } |
| if (e && e.code) { |
| socket.close(e.code, e.reason); |
| } |
| else { |
| observer.error(new TypeError('WebSocketSubject.error must be called with an object with an error code, ' + |
| 'and an optional reason: { code: number, reason: string }')); |
| } |
| _this._resetState(); |
| }, function () { |
| var closingObserver = _this.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.closeObserver; |
| if (closeObserver) { |
| closeObserver.next(e); |
| } |
| if (e.wasClean) { |
| observer.complete(); |
| } |
| else { |
| observer.error(e); |
| } |
| }; |
| socket.onmessage = function (e) { |
| var result = tryCatch(_this.resultSelector)(e); |
| if (result === errorObject) { |
| observer.error(errorObject.e); |
| } |
| else { |
| observer.next(result); |
| } |
| }; |
| }; |
| WebSocketSubject.prototype._subscribe = function (subscriber) { |
| var _this = this; |
| var source = this.source; |
| if (source) { |
| return source.subscribe(subscriber); |
| } |
| if (!this.socket) { |
| this._connectSocket(); |
| } |
| var subscription = new Subscription(); |
| subscription.add(this._output.subscribe(subscriber)); |
| subscription.add(function () { |
| var socket = _this.socket; |
| if (_this._output.observers.length === 0) { |
| if (socket && socket.readyState === 1) { |
| socket.close(); |
| } |
| _this._resetState(); |
| } |
| }); |
| return subscription; |
| }; |
| WebSocketSubject.prototype.unsubscribe = function () { |
| var _a = this, source = _a.source, socket = _a.socket; |
| if (socket && socket.readyState === 1) { |
| socket.close(); |
| this._resetState(); |
| } |
| _super.prototype.unsubscribe.call(this); |
| if (!source) { |
| this.destination = new ReplaySubject(); |
| } |
| }; |
| return WebSocketSubject; |
| }(AnonymousSubject)); |
| //# sourceMappingURL=WebSocketSubject.js.map |