text: /** PURE_IMPORTS_START tslib,_.._Subject,_.._Subscriber,_.._Observable,_.._Subscription,_.._ReplaySubject PURE_IMPORTS_END */
  /** 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
  