@folklore/socket 0.4.11 → 0.4.13

package/dist/cjs.js

@@ -2,22 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
-var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
-var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-var _createClass = require('@babel/runtime/helpers/createClass');
-var _assertThisInitialized = require('@babel/runtime/helpers/assertThisInitialized');
-var _inherits = require('@babel/runtime/helpers/inherits');
-var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
-var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
 var createDebug = require('debug');
 var EventEmitter = require('wolfy87-eventemitter');
 var invariant = require('invariant');
 var isFunction = require('lodash/isFunction');
 var isArray = require('lodash/isArray');
 var React = require('react');
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var PropTypes = require('prop-types');
 var jsxRuntime = require('react/jsx-runtime');
 var isString = require('lodash/isString');
@@ -42,827 +32,689 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
-var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
-var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
-var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-var _assertThisInitialized__default = /*#__PURE__*/_interopDefaultLegacy(_assertThisInitialized);
-var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
-var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
-var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);
 var createDebug__default = /*#__PURE__*/_interopDefaultLegacy(createDebug);
 var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
 var invariant__default = /*#__PURE__*/_interopDefaultLegacy(invariant);
 var isFunction__default = /*#__PURE__*/_interopDefaultLegacy(isFunction);
 var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
 var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
 var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
 
-function ownKeys$4(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+const debug$2 = createDebug__default["default"]('folklore:socket:pubnub');
 
-function _objectSpread$4(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$4(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$4(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _createSuper$2(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2(); return function _createSuperInternal() { var Super = _getPrototypeOf__default["default"](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default["default"](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default["default"](this, result); }; }
-
-function _isNativeReflectConstruct$2() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-var debug$2 = createDebug__default["default"]('folklore:socket:pubnub');
-
-var PubNubSocket = /*#__PURE__*/function (_EventEmitter) {
-  _inherits__default["default"](PubNubSocket, _EventEmitter);
-
-  var _super = _createSuper$2(PubNubSocket);
-
-  function PubNubSocket(opts) {
-    var _this;
-
-    _classCallCheck__default["default"](this, PubNubSocket);
-
-    _this = _super.call(this);
-    _this.options = _objectSpread$4({
+class PubNubSocket extends EventEmitter__default["default"] {
+  constructor(opts) {
+    super();
+    this.options = {
       uuid: null,
       publishKey: null,
       subscribeKey: null,
-      secretKey: null
-    }, opts);
-    _this.onReady = _this.onReady.bind(_assertThisInitialized__default["default"](_this));
-    _this.onStatus = _this.onStatus.bind(_assertThisInitialized__default["default"](_this));
-    _this.onMessage = _this.onMessage.bind(_assertThisInitialized__default["default"](_this));
-    _this.ready = false;
-    _this.shouldStart = false;
-    _this.started = false;
-    _this.starting = false;
-    _this.PubNub = null;
-    _this.pubnub = null;
-    _this.pubnubListener = null;
-    _this.channels = [];
-
-    _this.init();
-
-    return _this;
+      secretKey: null,
+      ...opts
+    };
+    this.onReady = this.onReady.bind(this);
+    this.onStatus = this.onStatus.bind(this);
+    this.onMessage = this.onMessage.bind(this);
+    this.destroyed = false;
+    this.ready = false;
+    this.shouldStart = false;
+    this.started = false;
+    this.starting = false;
+    this.PubNub = null;
+    this.pubnub = null;
+    this.pubnubListener = null;
+    this.channels = [];
+    this.init();
   }
 
-  _createClass__default["default"](PubNubSocket, [{
-    key: "onReady",
-    value: function onReady() {
-      this.ready = true;
-      this.emit('ready');
+  onReady() {
+    if (this.destroyed) {
+      return;
     }
-  }, {
-    key: "onStatus",
-    value: function onStatus(statusEvent) {
-      if (statusEvent.category === 'PNConnectedCategory' && !this.started) {
-        this.started = true;
-        this.starting = false;
-        this.emit('started');
-      }
-    }
-  }, {
-    key: "onMessage",
-    value: function onMessage(_ref) {
-      var message = _ref.message;
-      this.emit('message', message);
-
-      if (typeof message.event !== 'undefined') {
-        this.emit(message.event, message.data || message);
-      }
-    }
-  }, {
-    key: "updateChannels",
-    value: function updateChannels(channels) {
-      debug$2("Updating channels: ".concat(channels.join(', ')));
-      var shouldStart = this.shouldStart,
-          started = this.started,
-          starting = this.starting;
-
-      if (started || starting) {
-        this.stop();
-      }
 
-      this.channels = channels;
+    this.ready = true;
+    this.emit('ready');
+  }
 
-      if (started || starting || shouldStart) {
-        this.shouldStart = false;
-        this.start();
-      }
-    }
-  }, {
-    key: "init",
-    value: function init() {
-      var _this2 = this;
-
-      Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('pubnub')); }).then(function (_ref2) {
-        var PubNub = _ref2.default;
-        _this2.PubNub = PubNub;
-      }).then(function () {
-        return _this2.createPubNub();
-      }).then(function () {
-        return _this2.onReady();
-      });
+  onStatus(statusEvent) {
+    if (statusEvent.category === 'PNConnectedCategory' && !this.started) {
+      this.started = true;
+      this.starting = false;
+      this.emit('started');
     }
-  }, {
-    key: "createPubNub",
-    value: function createPubNub() {
-      var PubNub = this.PubNub;
-      var pubnubOptions = {
-        publishKey: this.options.publishKey,
-        subscribeKey: this.options.subscribeKey
-      };
-
-      if (this.options.uuid !== null) {
-        pubnubOptions.uuid = this.options.uuid;
-      }
+  }
 
-      if (this.options.secretKey !== null) {
-        pubnubOptions.secretKey = this.options.secretKey;
-      }
+  onMessage(_ref) {
+    let {
+      message
+    } = _ref;
+    this.emit('message', message);
 
-      this.pubnub = new PubNub(pubnubOptions);
-      this.pubnubListener = {
-        status: this.onStatus,
-        message: this.onMessage
-      };
-      this.pubnub.addListener(this.pubnubListener);
+    if (typeof message.event !== 'undefined') {
+      this.emit(message.event, message.data || message);
     }
-  }, {
-    key: "destroy",
-    value: function destroy() {
+  }
+
+  updateChannels(channels) {
+    debug$2("Updating channels: ".concat(channels.join(', ')));
+    const {
+      shouldStart,
+      started,
+      starting
+    } = this;
+
+    if (started || starting) {
       this.stop();
+    }
 
-      if (this.pubnubListener) {
-        this.pubnub.removeListener(this.pubnubListener);
-        this.pubnubListener = null;
-      }
+    this.channels = channels;
 
-      this.ready = false;
-      debug$2('Destroyed.');
+    if (started || starting || shouldStart) {
+      this.shouldStart = false;
+      this.start();
     }
-  }, {
-    key: "start",
-    value: function start() {
-      if (this.started) {
-        debug$2('Skipping start: Already started.');
-        return;
-      }
+  }
 
-      if (this.starting) {
-        debug$2('Skipping start: Already starting.');
-        return;
-      }
+  init() {
+    if (this.pubnub !== null) {
+      return;
+    }
 
-      if (this.channels.length === 0) {
-        debug$2('Skipping start: No channels.');
-        this.shouldStart = true;
-        return;
-      }
+    debug$2('Init');
+    this.destroyed = false;
+    const loadPubnub = this.PubNub !== null ? Promise.resolve() : this.loadPubNub();
+    loadPubnub.then(() => this.createPubNub()).then(() => this.onReady());
+  }
 
-      this.shouldStart = false;
-      this.starting = true;
-      this.pubnub.subscribe({
-        channels: this.channels
-      });
-      this.emit('start');
+  loadPubNub() {
+    debug$2('Load PubNub');
+    return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('pubnub')); }).then(_ref2 => {
+      let {
+        default: PubNub
+      } = _ref2;
+      this.PubNub = PubNub;
+    });
+  }
+
+  createPubNub() {
+    if (this.destroyed) {
+      return;
     }
-  }, {
-    key: "stop",
-    value: function stop() {
-      if (!this.started && !this.starting) {
-        return;
-      }
 
-      debug$2('Stopping...');
-      this.shouldStart = false;
-      this.started = false;
-      this.starting = false;
-      this.pubnub.unsubscribe({
-        channels: this.channels
-      });
-      this.emit('stop');
+    const {
+      PubNub
+    } = this;
+    const pubnubOptions = {
+      publishKey: this.options.publishKey,
+      subscribeKey: this.options.subscribeKey
+    };
+
+    if (this.options.uuid !== null) {
+      pubnubOptions.uuid = this.options.uuid;
     }
-  }, {
-    key: "send",
-    value: function send(data) {
-      var _this3 = this;
-
-      debug$2('Sending', data);
-      return new Promise(function (resolve, reject) {
-        _this3.pubnub.publish(data, function (status, response) {
-          if (status.error) {
-            reject(new Error("Error operation:".concat(status.operation, " status:").concat(status.statusCode)));
-          } else {
-            resolve({
-              status: status,
-              response: response,
-              data: data
-            });
-          }
-        });
-      });
+
+    if (this.options.secretKey !== null) {
+      pubnubOptions.secretKey = this.options.secretKey;
     }
-  }]);
 
-  return PubNubSocket;
-}(EventEmitter__default["default"]);
+    this.pubnub = new PubNub(pubnubOptions);
+    this.pubnubListener = {
+      status: this.onStatus,
+      message: this.onMessage
+    };
+    this.pubnub.addListener(this.pubnubListener);
+  }
 
-var _excluded$1 = ["host"];
+  destroy() {
+    this.destroyed = true;
+    this.stop();
 
-function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+    if (this.pubnubListener) {
+      this.pubnub.removeListener(this.pubnubListener);
+      this.pubnubListener = null;
+    }
 
-function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$3(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+    this.pubnub = null;
+    this.ready = false;
+    debug$2('Destroyed.');
+  }
 
-function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf__default["default"](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default["default"](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default["default"](this, result); }; }
+  start() {
+    if (this.started) {
+      debug$2('Skipping start: Already started.');
+      return;
+    }
 
-function _isNativeReflectConstruct$1() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-var debug$1 = createDebug__default["default"]('folklore:socket:socketio');
+    if (this.starting) {
+      debug$2('Skipping start: Already starting.');
+      return;
+    }
 
-var SocketIOSocket = /*#__PURE__*/function (_EventEmitter) {
-  _inherits__default["default"](SocketIOSocket, _EventEmitter);
+    if (this.channels.length === 0) {
+      debug$2('Skipping start: No channels.');
+      this.shouldStart = true;
+      return;
+    }
 
-  var _super = _createSuper$1(SocketIOSocket);
+    this.shouldStart = false;
+    this.starting = true;
+    this.pubnub.subscribe({
+      channels: this.channels
+    });
+    this.emit('start');
+  }
 
-  function SocketIOSocket(opts) {
-    var _this;
+  stop() {
+    if (!this.started && !this.starting) {
+      return;
+    }
 
-    _classCallCheck__default["default"](this, SocketIOSocket);
+    debug$2('Stopping...');
+    this.shouldStart = false;
+    this.started = false;
+    this.starting = false;
+    this.pubnub.unsubscribe({
+      channels: this.channels
+    });
+    this.emit('stop');
+  }
 
-    _this = _super.call(this);
-    _this.options = _objectSpread$3({
+  send(data) {
+    debug$2('Sending', data);
+    return new Promise((resolve, reject) => {
+      this.pubnub.publish(data, (status, response) => {
+        if (status.error) {
+          reject(new Error("Error operation:".concat(status.operation, " status:").concat(status.statusCode)));
+        } else {
+          resolve({
+            status,
+            response,
+            data
+          });
+        }
+      });
+    });
+  }
+
+}
+
+const debug$1 = createDebug__default["default"]('folklore:socket:socketio');
+
+class SocketIOSocket extends EventEmitter__default["default"] {
+  constructor(opts) {
+    super();
+    this.options = {
       uuid: null,
       host: 'http://127.0.0.1',
       path: null,
-      query: null
-    }, opts);
-    _this.onReady = _this.onReady.bind(_assertThisInitialized__default["default"](_this));
-    _this.onConnect = _this.onConnect.bind(_assertThisInitialized__default["default"](_this));
-    _this.onMessage = _this.onMessage.bind(_assertThisInitialized__default["default"](_this));
-    _this.ready = false;
-    _this.shouldStart = false;
-    _this.started = false;
-    _this.starting = false;
-    _this.Manager = null;
-    _this.io = null;
-    _this.sockets = {};
-    _this.channels = [];
-
-    _this.init();
-
-    return _this;
+      query: null,
+      ...opts
+    };
+    this.onReady = this.onReady.bind(this);
+    this.onConnect = this.onConnect.bind(this);
+    this.onMessage = this.onMessage.bind(this);
+    this.ready = false;
+    this.shouldStart = false;
+    this.started = false;
+    this.starting = false;
+    this.Manager = null;
+    this.io = null;
+    this.sockets = {};
+    this.channels = [];
+    this.init();
   }
 
-  _createClass__default["default"](SocketIOSocket, [{
-    key: "onReady",
-    value: function onReady() {
-      this.ready = true;
-      this.emit('ready');
-    }
-  }, {
-    key: "onConnect",
-    value: function onConnect(channel) {
-      debug$1('Socket connected on %s', channel);
-
-      if (!this.started) {
-        this.started = true;
-        this.starting = false;
-        this.emit('started');
-      }
-    }
-  }, {
-    key: "onMessage",
-    value: function onMessage(message, channel) {
-      debug$1('Message received on %s %o', channel, message);
-      this.emit('message', message, channel);
-    }
-  }, {
-    key: "init",
-    value: function init() {
-      var _this2 = this;
-
-      Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('socket.io-client')); }).then(function (_ref) {
-        var IO = _ref.default;
-        _this2.Manager = IO.Manager;
-      }).then(function () {
-        return _this2.createManager();
-      }).then(function () {
-        return _this2.onReady();
-      }).then(function () {
-        if (_this2.shouldStart) {
-          _this2.start();
-        }
-      });
-    }
-  }, {
-    key: "createManager",
-    value: function createManager() {
-      var Manager = this.Manager;
-
-      var _this$options = this.options,
-          host = _this$options.host,
-          opts = _objectWithoutProperties__default["default"](_this$options, _excluded$1);
-
-      this.io = new Manager(host, _objectSpread$3({
-        autoConnect: false
-      }, opts));
+  onReady() {
+    this.ready = true;
+    this.emit('ready');
+  }
+
+  onConnect(channel) {
+    debug$1('Socket connected on %s', channel);
+
+    if (!this.started) {
+      this.started = true;
+      this.starting = false;
+      this.emit('started');
     }
-  }, {
-    key: "updateChannels",
-    value: function updateChannels(channels) {
-      debug$1("Updating channels: ".concat(channels.join(', ')));
-      var shouldStart = this.shouldStart,
-          started = this.started,
-          starting = this.starting;
-
-      if (started || starting) {
-        this.stop();
-      }
+  }
 
-      this.channels = channels;
+  onMessage(message, channel) {
+    debug$1('Message received on %s %o', channel, message);
+    this.emit('message', message, channel);
+  }
 
-      if (started || starting || shouldStart) {
+  init() {
+    Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('socket.io-client')); }).then(_ref => {
+      let {
+        default: IO
+      } = _ref;
+      this.Manager = IO.Manager;
+    }).then(() => this.createManager()).then(() => this.onReady()).then(() => {
+      if (this.shouldStart) {
         this.start();
       }
-    }
-  }, {
-    key: "start",
-    value: function start() {
-      var _this3 = this;
-
-      if (this.started) {
-        debug$1('Skipping start: Already started.');
-        return;
-      }
+    });
+  }
 
-      if (this.starting) {
-        debug$1('Skipping start: Already starting.');
-        return;
-      }
+  createManager() {
+    const {
+      Manager
+    } = this;
+    const {
+      host,
+      ...opts
+    } = this.options;
+    this.io = new Manager(host, {
+      autoConnect: false,
+      ...opts
+    });
+  }
 
-      if (this.io === null) {
-        debug$1('Socket.io not ready.');
-        this.shouldStart = true;
-        return;
-      }
+  updateChannels(channels) {
+    debug$1("Updating channels: ".concat(channels.join(', ')));
+    const {
+      shouldStart,
+      started,
+      starting
+    } = this;
 
-      if (this.channels.length === 0) {
-        debug$1('Skipping start: No channels.');
-        this.shouldStart = true;
-        return;
-      }
+    if (started || starting) {
+      this.stop();
+    }
 
-      this.shouldStart = false;
-      this.starting = true;
-      this.sockets = this.channels.reduce(function (map, channel) {
-        return _objectSpread$3(_objectSpread$3({}, map), {}, _defineProperty__default["default"]({}, channel, _this3.createSocket(channel)));
-      }, {});
-      this.emit('start');
+    this.channels = channels;
+
+    if (started || starting || shouldStart) {
+      this.start();
     }
-  }, {
-    key: "stop",
-    value: function stop() {
-      var _this4 = this;
+  }
 
-      if (!this.started && !this.starting) {
-        return;
-      }
+  start() {
+    if (this.started) {
+      debug$1('Skipping start: Already started.');
+      return;
+    }
 
-      debug$1('Stopping...');
-      this.shouldStart = false;
-      this.started = false;
-      this.starting = false;
-      Object.values(this.sockets).forEach(function (socket) {
-        return _this4.stopSocket(socket);
-      });
-      this.emit('stop');
+    if (this.starting) {
+      debug$1('Skipping start: Already starting.');
+      return;
     }
-  }, {
-    key: "createSocket",
-    value: function createSocket(channel) {
-      var _this5 = this;
-
-      var socket = this.io.socket("/".concat(channel.replace(/^\//, '')));
-      socket.on('message', function (message) {
-        return _this5.onMessage(message, channel);
-      });
-      socket.on('connect', function () {
-        return _this5.onConnect(channel);
-      });
-      socket.open();
-      return socket;
-    } // eslint-disable-next-line class-methods-use-this
-
-  }, {
-    key: "stopSocket",
-    value: function stopSocket(socket) {
-      socket.off('connect');
-      socket.off('message');
-      socket.close();
-      return socket;
+
+    if (this.io === null) {
+      debug$1('Socket.io not ready.');
+      this.shouldStart = true;
+      return;
     }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      this.stop();
-      this.sockets = {};
 
-      if (this.io !== null) {
-        this.io.close();
-        this.io = null;
-      }
+    if (this.channels.length === 0) {
+      debug$1('Skipping start: No channels.');
+      this.shouldStart = true;
+      return;
     }
-  }, {
-    key: "send",
-    value: function send(data) {
-      var _this6 = this;
-
-      var channel = data.channel,
-          message = data.message;
-      var channels = !isArray__default["default"](channel) ? [channel] : channel;
-      channels.forEach(function (ch) {
-        _this6.sockets[ch].send(message);
-      });
-      return Promise.resolve();
+
+    this.shouldStart = false;
+    this.starting = true;
+    this.sockets = this.channels.reduce((map, channel) => ({ ...map,
+      [channel]: this.createSocket(channel)
+    }), {});
+    this.emit('start');
+  }
+
+  stop() {
+    if (!this.started && !this.starting) {
+      return;
     }
-  }]);
 
-  return SocketIOSocket;
-}(EventEmitter__default["default"]);
+    debug$1('Stopping...');
+    this.shouldStart = false;
+    this.started = false;
+    this.starting = false;
+    Object.values(this.sockets).forEach(socket => this.stopSocket(socket));
+    this.emit('stop');
+  }
 
-var SocketAdapters = {
-  PubNub: PubNubSocket,
-  SocketIO: SocketIOSocket
-};
+  createSocket(channel) {
+    const socket = this.io.socket("/".concat(channel.replace(/^\//, '')));
+    socket.on('message', message => this.onMessage(message, channel));
+    socket.on('connect', () => this.onConnect(channel));
+    socket.open();
+    return socket;
+  } // eslint-disable-next-line class-methods-use-this
 
-var _excluded = ["adapter", "channels"];
 
-function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+  stopSocket(socket) {
+    socket.off('connect');
+    socket.off('message');
+    socket.close();
+    return socket;
+  }
 
-function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$2(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+  destroy() {
+    this.stop();
+    this.sockets = {};
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf__default["default"](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default["default"](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default["default"](this, result); }; }
+    if (this.io !== null) {
+      this.io.close();
+      this.io = null;
+    }
+  }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+  send(data) {
+    const {
+      channel,
+      message
+    } = data;
+    const channels = !isArray__default["default"](channel) ? [channel] : channel;
+    channels.forEach(ch => {
+      this.sockets[ch].send(message);
+    });
+    return Promise.resolve();
+  }
 
-var normalize = function normalize(str) {
-  return str.replace(/[^a-z0-9]+/gi, '').toLowerCase();
+}
+
+var SocketAdapters = {
+  PubNub: PubNubSocket,
+  SocketIO: SocketIOSocket
 };
 
-var debug = createDebug__default["default"]('folklore:socket');
+const normalize = str => str.replace(/[^a-z0-9]+/gi, '').toLowerCase();
+
+const debug = createDebug__default["default"]('folklore:socket');
+
+class Socket extends EventEmitter__default["default"] {
+  static getAdapters() {
+    return Socket.adapters;
+  }
+
+  static getAdapter(adapter) {
+    // prettier-ignore
+    const adapterKey = Object.keys(Socket.adapters).find(key => normalize(key) === normalize(adapter)) || null;
 
-var Socket = /*#__PURE__*/function (_EventEmitter) {
-  _inherits__default["default"](Socket, _EventEmitter);
+    if (adapterKey === null) {
+      throw new Error("Adapter ".concat(adapter, " not found"));
+    }
 
-  var _super = _createSuper(Socket);
+    return Socket.adapters[adapterKey];
+  }
 
-  function Socket(opts) {
-    var _this;
+  static addAdapter(name, adapter) {
+    Socket.adapters = { ...Socket.adapters,
+      [name]: adapter
+    };
+    return Socket;
+  }
 
-    _classCallCheck__default["default"](this, Socket);
+  static setAdapters(adapters) {
+    Socket.adapters = adapters;
+    return Socket;
+  }
 
-    _this = _super.call(this);
-    _this.options = _objectSpread$2({
+  constructor(opts) {
+    super();
+    this.options = {
       adapter: 'pubnub',
       namespace: null,
       uuid: null,
       publishKey: null,
       subscribeKey: null,
       secretKey: null,
-      channels: []
-    }, opts);
-    _this.onAdapterReady = _this.onAdapterReady.bind(_assertThisInitialized__default["default"](_this));
-    _this.onAdapterStart = _this.onAdapterStart.bind(_assertThisInitialized__default["default"](_this));
-    _this.onAdapterStarted = _this.onAdapterStarted.bind(_assertThisInitialized__default["default"](_this));
-    _this.onAdapterMessage = _this.onAdapterMessage.bind(_assertThisInitialized__default["default"](_this));
-    _this.onAdapterStop = _this.onAdapterStop.bind(_assertThisInitialized__default["default"](_this));
-    _this.shouldStart = false;
-    _this.started = false;
-    _this.starting = false;
-    _this.ready = false;
-    _this.adapter = null;
-    _this.channels = [];
-
-    _this.init();
-
-    if (_this.options.channels.length) {
-      _this.setChannels(_this.options.channels);
+      channels: [],
+      ...opts
+    };
+    this.onAdapterReady = this.onAdapterReady.bind(this);
+    this.onAdapterStart = this.onAdapterStart.bind(this);
+    this.onAdapterStarted = this.onAdapterStarted.bind(this);
+    this.onAdapterMessage = this.onAdapterMessage.bind(this);
+    this.onAdapterStop = this.onAdapterStop.bind(this);
+    this.shouldStart = false;
+    this.started = false;
+    this.starting = false;
+    this.ready = false;
+    this.adapter = null;
+    this.channels = [];
+    this.init();
+
+    if (this.options.channels.length) {
+      this.setChannels(this.options.channels);
     }
-
-    return _this;
   }
 
-  _createClass__default["default"](Socket, [{
-    key: "onAdapterReady",
-    value: function onAdapterReady() {
-      debug('Adapter ready');
-      this.ready = true;
-      this.emit('ready');
+  onAdapterReady() {
+    debug('Adapter ready');
+    this.ready = true;
+    this.emit('ready');
 
-      if (this.shouldStart) {
-        this.shouldStart = false;
-        this.start();
-      }
-    }
-  }, {
-    key: "onAdapterStart",
-    value: function onAdapterStart() {
-      debug('Adapter starting...');
-      this.starting = true;
-      this.started = false;
-      this.emit('start');
-    }
-  }, {
-    key: "onAdapterStarted",
-    value: function onAdapterStarted() {
-      debug('Adapter started');
-      this.starting = false;
-      this.started = true;
-      this.emit('started');
-    }
-  }, {
-    key: "onAdapterStop",
-    value: function onAdapterStop() {
-      debug('Adapter stopped');
-      this.starting = false;
-      this.started = false;
-      this.emit('stop');
-    }
-  }, {
-    key: "onAdapterMessage",
-    value: function onAdapterMessage(message) {
-      debug('Adapter message', message);
-      this.emit('message', message);
+    if (this.shouldStart) {
+      this.shouldStart = false;
+      this.start();
     }
-  }, {
-    key: "getChannelWithoutNamespace",
-    value: function getChannelWithoutNamespace(name) {
-      if (this.options.namespace === null) {
-        return name;
-      }
+  }
 
-      var regExp = new RegExp("^".concat(this.options.namespace, ":"));
-      return name.replace(regExp, '');
-    }
-  }, {
-    key: "getChannelWithNamespace",
-    value: function getChannelWithNamespace(name) {
-      var parts = [];
+  onAdapterStart() {
+    debug('Adapter starting...');
+    this.starting = true;
+    this.started = false;
+    this.emit('start');
+  }
 
-      if (this.options.namespace !== null) {
-        parts.push(this.options.namespace);
-      }
+  onAdapterStarted() {
+    debug('Adapter started');
+    this.starting = false;
+    this.started = true;
+    this.emit('started');
+  }
+
+  onAdapterStop() {
+    debug('Adapter stopped');
+    this.starting = false;
+    this.started = false;
+    this.emit('stop');
+  }
+
+  onAdapterMessage(message) {
+    debug('Adapter message', message);
+    this.emit('message', message);
+  }
 
-      parts.push(name);
-      return parts.join(':');
+  getChannelWithoutNamespace(name) {
+    if (this.options.namespace === null) {
+      return name;
     }
-  }, {
-    key: "setChannels",
-    value: function setChannels(channels) {
-      var _this2 = this;
 
-      var namespacedChannels = channels.map(function (channel) {
-        return _this2.getChannelWithNamespace(channel);
-      }).sort();
+    const regExp = new RegExp("^".concat(this.options.namespace, ":"));
+    return name.replace(regExp, '');
+  }
 
-      if (this.channels.join(',') === namespacedChannels.join(',')) {
-        return;
-      }
+  getChannelWithNamespace(name) {
+    const parts = [];
 
-      debug("Set channels: ".concat(namespacedChannels.join(', ')));
-      this.updateChannels(namespacedChannels);
+    if (this.options.namespace !== null) {
+      parts.push(this.options.namespace);
     }
-  }, {
-    key: "addChannel",
-    value: function addChannel(channel) {
-      var namespacedChannel = this.getChannelWithNamespace(channel);
 
-      if (this.channels.indexOf(namespacedChannel) !== -1) {
-        return;
-      }
+    parts.push(name);
+    return parts.join(':');
+  }
 
-      debug("Adding channel: ".concat(channel));
-      this.updateChannels([].concat(_toConsumableArray__default["default"](this.channels), [namespacedChannel]));
-    }
-  }, {
-    key: "addChannels",
-    value: function addChannels(channels) {
-      var _this3 = this;
-
-      var namespacedChannels = channels.map(function (channel) {
-        return _this3.getChannelWithNamespace(channel);
-      }).sort();
-      debug("Adding channels: ".concat(channels.join(',')));
-      this.updateChannels([].concat(_toConsumableArray__default["default"](this.channels), _toConsumableArray__default["default"](namespacedChannels.filter(function (it) {
-        return _this3.channels.indexOf(it) === -1;
-      }))));
+  setChannels(channels) {
+    const namespacedChannels = channels.map(channel => this.getChannelWithNamespace(channel)).sort();
+
+    if (this.channels.join(',') === namespacedChannels.join(',')) {
+      return;
     }
-  }, {
-    key: "removeChannel",
-    value: function removeChannel(channel) {
-      var namespacedChannel = this.getChannelWithNamespace(channel);
 
-      if (this.channels.indexOf(namespacedChannel) === -1) {
-        return;
-      }
+    debug("Set channels: ".concat(namespacedChannels.join(', ')));
+    this.updateChannels(namespacedChannels);
+  }
 
-      debug("Removing channel: ".concat(channel));
-      this.updateChannels(this.channels.filter(function (ch) {
-        return ch !== namespacedChannel;
-      }));
-    }
-  }, {
-    key: "removeChannels",
-    value: function removeChannels(channels) {
-      var _this4 = this;
-
-      var namespacedChannels = channels.map(function (channel) {
-        return _this4.getChannelWithNamespace(channel);
-      }).sort();
-      debug("Removing channels: ".concat(channels.join(',')));
-      this.updateChannels(this.channels.filter(function (it) {
-        return namespacedChannels.indexOf(it) === -1;
-      }));
-    }
-  }, {
-    key: "updateChannels",
-    value: function updateChannels(channels) {
-      var sortedChannels = channels.sort();
-      debug("Updating channels: ".concat(sortedChannels.join(', ')));
-      this.channels = _toConsumableArray__default["default"](sortedChannels);
-
-      if (this.adapter !== null) {
-        this.adapter.updateChannels(sortedChannels);
-      }
-    }
-  }, {
-    key: "hasChannel",
-    value: function hasChannel(channel) {
-      var namespacedChannel = this.getChannelWithNamespace(channel);
-      return this.channels.reduce(function (found, it) {
-        return found || it === namespacedChannel;
-      }, false);
-    }
-  }, {
-    key: "getChannels",
-    value: function getChannels() {
-      var _this5 = this;
+  addChannel(channel) {
+    const namespacedChannel = this.getChannelWithNamespace(channel);
 
-      return this.channels.map(function (channel) {
-        return _this5.getChannelWithoutNamespace(channel);
-      });
-    }
-  }, {
-    key: "init",
-    value: function init() {
-      var _this6 = this;
-
-      var _this$options = this.options,
-          adapterKey = _this$options.adapter;
-          _this$options.channels;
-          var adapterOptions = _objectWithoutProperties__default["default"](_this$options, _excluded);
-
-      var SocketAdapter = Socket.getAdapter(adapterKey);
-      this.adapter = new SocketAdapter(adapterOptions);
-      var methods = ['start', 'stop', 'destroy', 'updateChannels', 'send'];
-      methods.forEach(function (method) {
-        invariant__default["default"](isFunction__default["default"](_this6.adapter[method] || null), "Socket adapter should implement method ".concat(method));
-      });
-      this.adapter.on('ready', this.onAdapterReady);
-      this.adapter.on('start', this.onAdapterStart);
-      this.adapter.on('started', this.onAdapterStarted);
-      this.adapter.on('message', this.onAdapterMessage);
-      this.adapter.on('stop', this.onAdapterStop);
+    if (this.channels.indexOf(namespacedChannel) !== -1) {
+      return;
     }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      if (this.adapter !== null) {
-        this.adapter.removeAllListeners();
-        this.adapter.destroy();
-        this.adapter = null;
-      }
 
-      this.started = false;
-      this.starting = false;
-      this.ready = false;
-      debug('Destroyed.');
-    }
-  }, {
-    key: "restart",
-    value: function restart() {
-      this.stop();
-      this.start();
+    debug("Adding channel: ".concat(channel));
+    this.updateChannels([...this.channels, namespacedChannel]);
+  }
+
+  addChannels(channels) {
+    const namespacedChannels = channels.map(channel => this.getChannelWithNamespace(channel)).sort();
+    debug("Adding channels: ".concat(channels.join(',')));
+    this.updateChannels([...this.channels, ...namespacedChannels.filter(it => this.channels.indexOf(it) === -1)]);
+  }
+
+  removeChannel(channel) {
+    const namespacedChannel = this.getChannelWithNamespace(channel);
+
+    if (this.channels.indexOf(namespacedChannel) === -1) {
+      return;
     }
-  }, {
-    key: "start",
-    value: function start() {
-      var _this7 = this;
-
-      if (this.started) {
-        debug('Skipping start: Already started.');
-        return;
-      }
 
-      if (this.starting) {
-        debug('Skipping start: Already starting.');
-        return;
-      }
+    debug("Removing channel: ".concat(channel));
+    this.updateChannels(this.channels.filter(ch => ch !== namespacedChannel));
+  }
 
-      if (!this.ready) {
-        debug('Skipping start: No ready.');
-        this.shouldStart = true;
-        return;
-      }
+  removeChannels(channels) {
+    const namespacedChannels = channels.map(channel => this.getChannelWithNamespace(channel)).sort();
+    debug("Removing channels: ".concat(channels.join(',')));
+    this.updateChannels(this.channels.filter(it => namespacedChannels.indexOf(it) === -1));
+  }
 
-      this.shouldStart = false;
-      debug('Starting on channels:');
-      this.channels.forEach(function (channel) {
-        debug("- ".concat(_this7.getChannelWithoutNamespace(channel)));
-      });
-      this.adapter.start();
+  updateChannels(channels) {
+    const sortedChannels = channels.sort();
+    debug("Updating channels: ".concat(sortedChannels.join(', ')));
+    this.channels = [...sortedChannels];
+
+    if (this.adapter !== null) {
+      this.adapter.updateChannels(sortedChannels);
     }
-  }, {
-    key: "stop",
-    value: function stop() {
-      this.shouldStart = false;
+  }
 
-      if (!this.started && !this.starting) {
-        return;
-      }
+  hasChannel(channel) {
+    const namespacedChannel = this.getChannelWithNamespace(channel);
+    return this.channels.reduce((found, it) => found || it === namespacedChannel, false);
+  }
 
-      debug('Stopping...');
+  getChannels() {
+    return this.channels.map(channel => this.getChannelWithoutNamespace(channel));
+  }
 
-      if (this.adapter !== null) {
-        this.adapter.stop();
-      }
+  init() {
+    if (this.adapter !== null) {
+      debug('Already initialized');
+      return;
+    }
+
+    debug('Init');
+    const {
+      adapter: adapterKey,
+      channels,
+      ...adapterOptions
+    } = this.options;
+    const SocketAdapter = Socket.getAdapter(adapterKey);
+    this.adapter = new SocketAdapter(adapterOptions);
+    const methods = ['start', 'stop', 'destroy', 'updateChannels', 'send'];
+    methods.forEach(method => {
+      invariant__default["default"](isFunction__default["default"](this.adapter[method] || null), "Socket adapter should implement method ".concat(method));
+    });
+    this.adapter.on('ready', this.onAdapterReady);
+    this.adapter.on('start', this.onAdapterStart);
+    this.adapter.on('started', this.onAdapterStarted);
+    this.adapter.on('message', this.onAdapterMessage);
+    this.adapter.on('stop', this.onAdapterStop);
+  }
+
+  destroy() {
+    if (this.adapter !== null) {
+      this.adapter.removeAllListeners();
+      this.adapter.destroy();
+      this.adapter = null;
     }
-  }, {
-    key: "send",
-    value: function send(data, channel) {
-      if (!this.started) {
-        debug('Abort sending data: Not started');
-        return Promise.reject();
-      }
 
-      var publishData = typeof data.channel !== 'undefined' && typeof data.message !== 'undefined' ? data : {
-        channel: typeof channel !== 'undefined' ? this.getChannelWithNamespace(channel) : this.channels,
-        message: data
-      };
-      debug('Sending', publishData);
-      return this.adapter.send(publishData);
+    this.started = false;
+    this.starting = false;
+    this.ready = false;
+    debug('Destroyed.');
+  }
+
+  restart() {
+    this.stop();
+    this.start();
+  }
+
+  start() {
+    if (this.started) {
+      debug('Skipping start: Already started.');
+      return;
     }
-  }, {
-    key: "isStarted",
-    value: function isStarted() {
-      return this.started;
+
+    if (this.starting) {
+      debug('Skipping start: Already starting.');
+      return;
     }
-  }], [{
-    key: "getAdapters",
-    value: function getAdapters() {
-      return Socket.adapters;
+
+    if (!this.ready) {
+      debug('Skipping start: No ready.');
+      this.shouldStart = true;
+      return;
     }
-  }, {
-    key: "getAdapter",
-    value: function getAdapter(adapter) {
-      // prettier-ignore
-      var adapterKey = Object.keys(Socket.adapters).find(function (key) {
-        return normalize(key) === normalize(adapter);
-      }) || null;
-
-      if (adapterKey === null) {
-        throw new Error("Adapter ".concat(adapter, " not found"));
-      }
 
-      return Socket.adapters[adapterKey];
+    this.shouldStart = false;
+    debug('Starting on channels:');
+    this.channels.forEach(channel => {
+      debug("- ".concat(this.getChannelWithoutNamespace(channel)));
+    });
+    this.adapter.start();
+  }
+
+  stop() {
+    this.shouldStart = false;
+
+    if (!this.started && !this.starting) {
+      return;
     }
-  }, {
-    key: "addAdapter",
-    value: function addAdapter(name, adapter) {
-      Socket.adapters = _objectSpread$2(_objectSpread$2({}, Socket.adapters), {}, _defineProperty__default["default"]({}, name, adapter));
-      return Socket;
+
+    debug('Stopping...');
+
+    if (this.adapter !== null) {
+      this.adapter.stop();
     }
-  }, {
-    key: "setAdapters",
-    value: function setAdapters(adapters) {
-      Socket.adapters = adapters;
-      return Socket;
+  }
+
+  send(data, channel) {
+    if (!this.started) {
+      debug('Abort sending data: Not started');
+      return Promise.reject();
     }
-  }]);
 
-  return Socket;
-}(EventEmitter__default["default"]);
+    const publishData = typeof data.channel !== 'undefined' && typeof data.message !== 'undefined' ? data : {
+      channel: typeof channel !== 'undefined' ? this.getChannelWithNamespace(channel) : this.channels,
+      message: data
+    };
+    debug('Sending', publishData);
+    return this.adapter.send(publishData);
+  }
+
+  isStarted() {
+    return this.started;
+  }
+
+}
 
-Socket.adapters = _objectSpread$2({}, SocketAdapters);
+Socket.adapters = { ...SocketAdapters
+};
 
-var SocketContext = /*#__PURE__*/React__default["default"].createContext({
+const SocketContext = /*#__PURE__*/React__default["default"].createContext({
   socket: null,
-  subscribe: function subscribe() {},
-  unsubscribe: function unsubscribe() {}
+  subscribe: () => {},
+  unsubscribe: () => {}
 });
 
-function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var propTypes = {
+const propTypes = {
   socket: PropTypes__default["default"].instanceOf(Socket),
   adapter: PropTypes__default["default"].string,
   host: PropTypes__default["default"].string,
@@ -875,7 +727,7 @@ var propTypes = {
   autoStart: PropTypes__default["default"].bool,
   children: PropTypes__default["default"].node
 };
-var defaultProps = {
+const defaultProps = {
   socket: null,
   adapter: 'pubnub',
   host: null,
@@ -889,82 +741,73 @@ var defaultProps = {
   children: null
 };
 
-var SocketContainer = function SocketContainer(_ref) {
-  var children = _ref.children,
-      socket = _ref.socket,
-      autoStart = _ref.autoStart,
-      adapter = _ref.adapter,
-      host = _ref.host,
-      namespace = _ref.namespace,
-      uuid = _ref.uuid,
-      publishKey = _ref.publishKey,
-      subscribeKey = _ref.subscribeKey,
-      secretKey = _ref.secretKey,
-      initialChannels = _ref.channels;
-  var finalSocket = React.useMemo(function () {
-    return socket || new Socket({
-      adapter: adapter,
-      host: host,
-      namespace: namespace,
-      uuid: uuid,
-      publishKey: publishKey,
-      subscribeKey: subscribeKey,
-      secretKey: secretKey
-    });
-  }, [socket, host, adapter, namespace, uuid, publishKey, subscribeKey, secretKey]);
-
-  var _useState = React.useState([]),
-      _useState2 = _slicedToArray__default["default"](_useState, 2),
-      channels = _useState2[0],
-      setChannels = _useState2[1];
-
-  var channelsCountRef = React.useRef({});
-  var updateChannels = React.useCallback(function (newChannels) {
+const SocketContainer = function (_ref) {
+  let {
+    children,
+    socket,
+    autoStart,
+    adapter,
+    host,
+    namespace,
+    uuid,
+    publishKey,
+    subscribeKey,
+    secretKey,
+    channels: initialChannels
+  } = _ref;
+  const finalSocket = React.useMemo(() => socket || new Socket({
+    adapter,
+    host,
+    namespace,
+    uuid,
+    publishKey,
+    subscribeKey,
+    secretKey
+  }), [socket, host, adapter, namespace, uuid, publishKey, subscribeKey, secretKey]);
+  const [channels, setChannels] = React.useState([]);
+  const channelsCountRef = React.useRef({});
+  const updateChannels = React.useCallback(newChannels => {
     finalSocket.setChannels(newChannels);
     setChannels(newChannels);
   }, [finalSocket, setChannels]);
-  var addToChannelsCount = React.useCallback(function (newChannels) {
-    channelsCountRef.current = newChannels.reduce(function (map, channel) {
-      return _objectSpread$1(_objectSpread$1({}, map), {}, _defineProperty__default["default"]({}, channel, (map[channel] || 0) + 1));
-    }, channelsCountRef.current);
+  const addToChannelsCount = React.useCallback(newChannels => {
+    channelsCountRef.current = newChannels.reduce((map, channel) => ({ ...map,
+      [channel]: (map[channel] || 0) + 1
+    }), channelsCountRef.current);
     updateChannels(Object.keys(channelsCountRef.current));
   }, [updateChannels]);
-  var removeToChannelsCount = React.useCallback(function (newChannels) {
-    channelsCountRef.current = newChannels.reduce(function (map, channel) {
-      var newCount = (map[channel] || 0) - 1;
-      return newCount > 0 ? _objectSpread$1(_objectSpread$1({}, map), {}, _defineProperty__default["default"]({}, channel, newCount)) : map;
+  const removeToChannelsCount = React.useCallback(newChannels => {
+    channelsCountRef.current = newChannels.reduce((map, channel) => {
+      const newCount = (map[channel] || 0) - 1;
+      return newCount > 0 ? { ...map,
+        [channel]: newCount
+      } : map;
     }, channelsCountRef.current);
     updateChannels(Object.keys(channelsCountRef.current));
   }, [updateChannels]);
-  var subscribe = React.useCallback(function (channelsToAdd) {
-    return addToChannelsCount(channelsToAdd);
-  }, [addToChannelsCount]);
-  var unsubscribe = React.useCallback(function (channelsToRemove) {
-    return removeToChannelsCount(channelsToRemove);
-  }, [removeToChannelsCount]);
-  React.useEffect(function () {
+  const subscribe = React.useCallback(channelsToAdd => addToChannelsCount(channelsToAdd), [addToChannelsCount]);
+  const unsubscribe = React.useCallback(channelsToRemove => removeToChannelsCount(channelsToRemove), [removeToChannelsCount]);
+  React.useEffect(() => {
     subscribe(initialChannels);
-    return function () {
+    return () => {
       unsubscribe(initialChannels);
     };
   }, [initialChannels, subscribe, unsubscribe]);
-  React.useEffect(function () {
+  React.useEffect(() => {
     if (autoStart) {
       finalSocket.start();
     }
 
-    return function () {
+    return () => {
       finalSocket.destroy();
     };
   }, [autoStart, finalSocket]);
-  var value = React.useMemo(function () {
-    return {
-      socket: finalSocket,
-      subscribe: subscribe,
-      unsubscribe: unsubscribe,
-      channels: channels
-    };
-  }, [finalSocket, subscribe]);
+  const value = React.useMemo(() => ({
+    socket: finalSocket,
+    subscribe,
+    unsubscribe,
+    channels
+  }), [finalSocket, subscribe]);
   return /*#__PURE__*/jsxRuntime.jsx(SocketContext.Provider, {
     value: value,
     children: children
@@ -974,75 +817,58 @@ var SocketContainer = function SocketContainer(_ref) {
 SocketContainer.propTypes = propTypes;
 SocketContainer.defaultProps = defaultProps;
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-var getDisplayName = function getDisplayName(WrappedComponent) {
-  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
-};
-
-var withSocket = function withSocket(WrappedComponent) {
-  var WithSocketComponent = function WithSocketComponent(props) {
-    return /*#__PURE__*/jsxRuntime.jsx(SocketContext.Consumer, {
-      children: function children(_ref) {
-        var socket = _ref.socket,
-            subscribe = _ref.subscribe,
-            unsubscribe = _ref.unsubscribe;
-        return /*#__PURE__*/jsxRuntime.jsx(WrappedComponent, _objectSpread({
-          socket: socket,
-          socketSubscribe: subscribe,
-          socketUnsubscribe: unsubscribe
-        }, props));
-      }
-    });
-  };
+const getDisplayName = WrappedComponent => WrappedComponent.displayName || WrappedComponent.name || 'Component';
+
+const withSocket = WrappedComponent => {
+  const WithSocketComponent = props => /*#__PURE__*/jsxRuntime.jsx(SocketContext.Consumer, {
+    children: _ref => {
+      let {
+        socket,
+        subscribe,
+        unsubscribe
+      } = _ref;
+      return /*#__PURE__*/jsxRuntime.jsx(WrappedComponent, {
+        socket: socket,
+        socketSubscribe: subscribe,
+        socketUnsubscribe: unsubscribe,
+        ...props
+      });
+    }
+  });
 
   WithSocketComponent.displayName = "WithSocket(".concat(getDisplayName(WrappedComponent), ")");
   return WithSocketComponent;
 };
 
-var useSocket = function useSocket() {
-  var channelNames = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-
-  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-      _ref$socket = _ref.socket,
-      customSocket = _ref$socket === void 0 ? null : _ref$socket,
-      _ref$onMessage = _ref.onMessage,
-      customOnMessage = _ref$onMessage === void 0 ? null : _ref$onMessage;
-
-  var _useContext = React.useContext(SocketContext),
-      contextSocket = _useContext.socket,
-      subscribe = _useContext.subscribe,
-      unsubscribe = _useContext.unsubscribe;
-
-  var socket = customSocket || contextSocket || null;
-
-  var _useState = React.useState(socket !== null ? socket.isStarted() : false),
-      _useState2 = _slicedToArray__default["default"](_useState, 2),
-      started = _useState2[0],
-      setStarted = _useState2[1];
-
-  var channels = isString__default["default"](channelNames) ? [channelNames] : channelNames;
-  var channelsKey = (channels || []).sort().join(',');
-  React.useEffect(function () {
+const useSocket = function () {
+  let channelNames = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  let {
+    socket: customSocket = null,
+    onMessage: customOnMessage = null
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const {
+    socket: contextSocket,
+    subscribe,
+    unsubscribe
+  } = React.useContext(SocketContext);
+  const socket = customSocket || contextSocket || null;
+  const [started, setStarted] = React.useState(socket !== null ? socket.isStarted() : false);
+  const channels = isString__default["default"](channelNames) ? [channelNames] : channelNames;
+  const channelsKey = (channels || []).sort().join(',');
+  React.useEffect(() => {
     if (socket === null) {
       if (process.env.NODE_ENV !== 'production') {
         console.warn('Socket context is empty.');
       }
 
-      return function () {};
+      return () => {};
     }
 
-    var wasStarted = socket.isStarted();
+    const wasStarted = socket.isStarted();
 
-    var onStarted = function onStarted() {
-      return setStarted(true);
-    };
+    const onStarted = () => setStarted(true);
 
-    var onStop = function onStop() {
-      return setStarted(false);
-    };
+    const onStop = () => setStarted(false);
 
     socket.on('stop', onStop);
     socket.on('started', onStarted);
@@ -1055,7 +881,7 @@ var useSocket = function useSocket() {
       socket.start();
     }
 
-    return function () {
+    return () => {
       socket.off('stop', onStop);
       socket.off('started', onStarted);
 
@@ -1068,27 +894,27 @@ var useSocket = function useSocket() {
       }
     };
   }, [channelsKey, customSocket]);
-  React.useEffect(function () {
+  React.useEffect(() => {
     if (socket === null) {
-      return function () {};
+      return () => {};
     }
 
-    var onMessage = function onMessage() {
+    const onMessage = function () {
       if (customOnMessage !== null) {
-        customOnMessage.apply(void 0, arguments);
+        customOnMessage(...arguments);
       }
     };
 
     socket.on('message', onMessage);
-    return function () {
+    return () => {
       socket.off('message', onMessage);
     };
   }, [customOnMessage]);
   return {
-    socket: socket,
-    started: started,
-    subscribe: subscribe,
-    unsubscribe: unsubscribe
+    socket,
+    started,
+    subscribe,
+    unsubscribe
   };
 };