text: 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 = (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