@folklore/socket 0.4.1 → 0.4.9

package/dist/es.js

@@ -0,0 +1,1052 @@
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _assertThisInitialized from '@babel/runtime/helpers/assertThisInitialized';
+import _inherits from '@babel/runtime/helpers/inherits';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import createDebug from 'debug';
+import EventEmitter from 'wolfy87-eventemitter';
+import invariant from 'invariant';
+import isFunction from 'lodash/isFunction';
+import isArray from 'lodash/isArray';
+import React, { useMemo, useState, useRef, useCallback, useEffect, useContext } from 'react';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import PropTypes from 'prop-types';
+import { jsx } from 'react/jsx-runtime';
+import isString from 'lodash/isString';
+
+function ownKeys$4(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread$4(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$4(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(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('folklore:socket:pubnub');
+
+var PubNubSocket = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(PubNubSocket, _EventEmitter);
+
+  var _super = _createSuper$2(PubNubSocket);
+
+  function PubNubSocket(opts) {
+    var _this;
+
+    _classCallCheck(this, PubNubSocket);
+
+    _this = _super.call(this);
+    _this.options = _objectSpread$4({
+      uuid: null,
+      publishKey: null,
+      subscribeKey: null,
+      secretKey: null
+    }, opts);
+    _this.onReady = _this.onReady.bind(_assertThisInitialized(_this));
+    _this.onStatus = _this.onStatus.bind(_assertThisInitialized(_this));
+    _this.onMessage = _this.onMessage.bind(_assertThisInitialized(_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;
+  }
+
+  _createClass(PubNubSocket, [{
+    key: "onReady",
+    value: function onReady() {
+      this.ready = true;
+      this.emit('ready');
+    }
+  }, {
+    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;
+
+      if (started || starting || shouldStart) {
+        this.shouldStart = false;
+        this.start();
+      }
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      var _this2 = this;
+
+      import('pubnub').then(function (_ref2) {
+        var PubNub = _ref2.default;
+        _this2.PubNub = PubNub;
+      }).then(function () {
+        return _this2.createPubNub();
+      }).then(function () {
+        return _this2.onReady();
+      });
+    }
+  }, {
+    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;
+      }
+
+      this.pubnub = new PubNub(pubnubOptions);
+      this.pubnubListener = {
+        status: this.onStatus,
+        message: this.onMessage
+      };
+      this.pubnub.addListener(this.pubnubListener);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.stop();
+
+      if (this.pubnubListener) {
+        this.pubnub.removeListener(this.pubnubListener);
+        this.pubnubListener = null;
+      }
+
+      this.ready = false;
+      debug$2('Destroyed.');
+    }
+  }, {
+    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;
+      }
+
+      if (this.channels.length === 0) {
+        debug$2('Skipping start: No channels.');
+        this.shouldStart = true;
+        return;
+      }
+
+      this.shouldStart = false;
+      this.starting = true;
+      this.pubnub.subscribe({
+        channels: this.channels
+      });
+      this.emit('start');
+    }
+  }, {
+    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');
+    }
+  }, {
+    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
+            });
+          }
+        });
+      });
+    }
+  }]);
+
+  return PubNubSocket;
+}(EventEmitter);
+
+var _excluded$1 = ["host"];
+
+function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$3(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+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('folklore:socket:socketio');
+
+var SocketIOSocket = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(SocketIOSocket, _EventEmitter);
+
+  var _super = _createSuper$1(SocketIOSocket);
+
+  function SocketIOSocket(opts) {
+    var _this;
+
+    _classCallCheck(this, SocketIOSocket);
+
+    _this = _super.call(this);
+    _this.options = _objectSpread$3({
+      uuid: null,
+      host: 'http://127.0.0.1',
+      path: null,
+      query: null
+    }, opts);
+    _this.onReady = _this.onReady.bind(_assertThisInitialized(_this));
+    _this.onConnect = _this.onConnect.bind(_assertThisInitialized(_this));
+    _this.onMessage = _this.onMessage.bind(_assertThisInitialized(_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;
+  }
+
+  _createClass(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;
+
+      import('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(_this$options, _excluded$1);
+
+      this.io = new Manager(host, _objectSpread$3({
+        autoConnect: false
+      }, opts));
+    }
+  }, {
+    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;
+
+      if (started || starting || 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;
+      }
+
+      if (this.io === null) {
+        debug$1('Socket.io not ready.');
+        this.shouldStart = true;
+        return;
+      }
+
+      if (this.channels.length === 0) {
+        debug$1('Skipping start: No channels.');
+        this.shouldStart = true;
+        return;
+      }
+
+      this.shouldStart = false;
+      this.starting = true;
+      this.sockets = this.channels.reduce(function (map, channel) {
+        return _objectSpread$3(_objectSpread$3({}, map), {}, _defineProperty({}, channel, _this3.createSocket(channel)));
+      }, {});
+      this.emit('start');
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      var _this4 = this;
+
+      if (!this.started && !this.starting) {
+        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');
+    }
+  }, {
+    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;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.stop();
+      this.sockets = {};
+
+      if (this.io !== null) {
+        this.io.close();
+        this.io = null;
+      }
+    }
+  }, {
+    key: "send",
+    value: function send(data) {
+      var _this6 = this;
+
+      var channel = data.channel,
+          message = data.message;
+      var channels = !isArray(channel) ? [channel] : channel;
+      channels.forEach(function (ch) {
+        _this6.sockets[ch].send(message);
+      });
+      return Promise.resolve();
+    }
+  }]);
+
+  return SocketIOSocket;
+}(EventEmitter);
+
+var SocketAdapters = {
+  PubNub: PubNubSocket,
+  SocketIO: SocketIOSocket
+};
+
+var _excluded = ["adapter", "channels"];
+
+function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+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; } }
+
+var normalize = function normalize(str) {
+  return str.replace(/[^a-z0-9]+/gi, '').toLowerCase();
+};
+
+var debug = createDebug('folklore:socket');
+
+var Socket = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(Socket, _EventEmitter);
+
+  var _super = _createSuper(Socket);
+
+  function Socket(opts) {
+    var _this;
+
+    _classCallCheck(this, Socket);
+
+    _this = _super.call(this);
+    _this.options = _objectSpread$2({
+      adapter: 'pubnub',
+      namespace: null,
+      uuid: null,
+      publishKey: null,
+      subscribeKey: null,
+      secretKey: null,
+      channels: []
+    }, opts);
+    _this.onAdapterReady = _this.onAdapterReady.bind(_assertThisInitialized(_this));
+    _this.onAdapterStart = _this.onAdapterStart.bind(_assertThisInitialized(_this));
+    _this.onAdapterStarted = _this.onAdapterStarted.bind(_assertThisInitialized(_this));
+    _this.onAdapterMessage = _this.onAdapterMessage.bind(_assertThisInitialized(_this));
+    _this.onAdapterStop = _this.onAdapterStop.bind(_assertThisInitialized(_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(Socket, [{
+    key: "onAdapterReady",
+    value: function 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);
+    }
+  }, {
+    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 = [];
+
+      if (this.options.namespace !== null) {
+        parts.push(this.options.namespace);
+      }
+
+      parts.push(name);
+      return parts.join(':');
+    }
+  }, {
+    key: "setChannels",
+    value: function setChannels(channels) {
+      var _this2 = this;
+
+      var namespacedChannels = channels.map(function (channel) {
+        return _this2.getChannelWithNamespace(channel);
+      }).sort();
+
+      if (this.channels.join(',') === namespacedChannels.join(',')) {
+        return;
+      }
+
+      debug("Set channels: ".concat(namespacedChannels.join(', ')));
+      this.updateChannels(namespacedChannels);
+    }
+  }, {
+    key: "addChannel",
+    value: function addChannel(channel) {
+      var namespacedChannel = this.getChannelWithNamespace(channel);
+
+      if (this.channels.indexOf(namespacedChannel) !== -1) {
+        return;
+      }
+
+      debug("Adding channel: ".concat(channel));
+      this.updateChannels([].concat(_toConsumableArray(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(this.channels), _toConsumableArray(namespacedChannels.filter(function (it) {
+        return _this3.channels.indexOf(it) === -1;
+      }))));
+    }
+  }, {
+    key: "removeChannel",
+    value: function removeChannel(channel) {
+      var namespacedChannel = this.getChannelWithNamespace(channel);
+
+      if (this.channels.indexOf(namespacedChannel) === -1) {
+        return;
+      }
+
+      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(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;
+
+      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(_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(isFunction(_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);
+    }
+  }, {
+    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();
+    }
+  }, {
+    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;
+      }
+
+      if (!this.ready) {
+        debug('Skipping start: No ready.');
+        this.shouldStart = true;
+        return;
+      }
+
+      this.shouldStart = false;
+      debug('Starting on channels:');
+      this.channels.forEach(function (channel) {
+        debug("- ".concat(_this7.getChannelWithoutNamespace(channel)));
+      });
+      this.adapter.start();
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      this.shouldStart = false;
+
+      if (!this.started && !this.starting) {
+        return;
+      }
+
+      debug('Stopping...');
+
+      if (this.adapter !== null) {
+        this.adapter.stop();
+      }
+    }
+  }, {
+    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);
+    }
+  }, {
+    key: "isStarted",
+    value: function isStarted() {
+      return this.started;
+    }
+  }], [{
+    key: "getAdapters",
+    value: function getAdapters() {
+      return Socket.adapters;
+    }
+  }, {
+    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];
+    }
+  }, {
+    key: "addAdapter",
+    value: function addAdapter(name, adapter) {
+      Socket.adapters = _objectSpread$2(_objectSpread$2({}, Socket.adapters), {}, _defineProperty({}, name, adapter));
+      return Socket;
+    }
+  }, {
+    key: "setAdapters",
+    value: function setAdapters(adapters) {
+      Socket.adapters = adapters;
+      return Socket;
+    }
+  }]);
+
+  return Socket;
+}(EventEmitter);
+
+Socket.adapters = _objectSpread$2({}, SocketAdapters);
+
+var SocketContext = /*#__PURE__*/React.createContext({
+  socket: null,
+  subscribe: function subscribe() {},
+  unsubscribe: function unsubscribe() {}
+});
+
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+var propTypes = {
+  socket: PropTypes.instanceOf(Socket),
+  adapter: PropTypes.string,
+  host: PropTypes.string,
+  namespace: PropTypes.string,
+  uuid: PropTypes.string,
+  publishKey: PropTypes.string,
+  subscribeKey: PropTypes.string,
+  secretKey: PropTypes.string,
+  channels: PropTypes.arrayOf(PropTypes.string),
+  autoStart: PropTypes.bool,
+  children: PropTypes.node
+};
+var defaultProps = {
+  socket: null,
+  adapter: 'pubnub',
+  host: null,
+  namespace: null,
+  uuid: null,
+  publishKey: null,
+  subscribeKey: null,
+  secretKey: null,
+  channels: [],
+  autoStart: false,
+  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 = 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 = useState([]),
+      _useState2 = _slicedToArray(_useState, 2),
+      channels = _useState2[0],
+      setChannels = _useState2[1];
+
+  var channelsCountRef = useRef({});
+  var updateChannels = useCallback(function (newChannels) {
+    finalSocket.setChannels(newChannels);
+    setChannels(newChannels);
+  }, [finalSocket, setChannels]);
+  var addToChannelsCount = useCallback(function (newChannels) {
+    channelsCountRef.current = newChannels.reduce(function (map, channel) {
+      return _objectSpread$1(_objectSpread$1({}, map), {}, _defineProperty({}, channel, (map[channel] || 0) + 1));
+    }, channelsCountRef.current);
+    updateChannels(Object.keys(channelsCountRef.current));
+  }, [updateChannels]);
+  var removeToChannelsCount = 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({}, channel, newCount)) : map;
+    }, channelsCountRef.current);
+    updateChannels(Object.keys(channelsCountRef.current));
+  }, [updateChannels]);
+  var subscribe = useCallback(function (channelsToAdd) {
+    return addToChannelsCount(channelsToAdd);
+  }, [addToChannelsCount]);
+  var unsubscribe = useCallback(function (channelsToRemove) {
+    return removeToChannelsCount(channelsToRemove);
+  }, [removeToChannelsCount]);
+  useEffect(function () {
+    subscribe(initialChannels);
+    return function () {
+      unsubscribe(initialChannels);
+    };
+  }, [initialChannels, subscribe, unsubscribe]);
+  useEffect(function () {
+    if (autoStart) {
+      finalSocket.start();
+    }
+
+    return function () {
+      finalSocket.destroy();
+    };
+  }, [autoStart, finalSocket]);
+  var value = useMemo(function () {
+    return {
+      socket: finalSocket,
+      subscribe: subscribe,
+      unsubscribe: unsubscribe,
+      channels: channels
+    };
+  }, [finalSocket, subscribe]);
+  return /*#__PURE__*/jsx(SocketContext.Provider, {
+    value: value,
+    children: children
+  });
+};
+
+SocketContainer.propTypes = propTypes;
+SocketContainer.defaultProps = defaultProps;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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__*/jsx(SocketContext.Consumer, {
+      children: function children(_ref) {
+        var socket = _ref.socket,
+            subscribe = _ref.subscribe,
+            unsubscribe = _ref.unsubscribe;
+        return /*#__PURE__*/jsx(WrappedComponent, _objectSpread({
+          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 = useContext(SocketContext),
+      contextSocket = _useContext.socket,
+      subscribe = _useContext.subscribe,
+      unsubscribe = _useContext.unsubscribe;
+
+  var socket = customSocket || contextSocket || null;
+
+  var _useState = useState(socket !== null ? socket.isStarted() : false),
+      _useState2 = _slicedToArray(_useState, 2),
+      started = _useState2[0],
+      setStarted = _useState2[1];
+
+  var channels = isString(channelNames) ? [channelNames] : channelNames;
+  var channelsKey = (channels || []).sort().join(',');
+  useEffect(function () {
+    if (socket === null) {
+      if (process.env.NODE_ENV !== 'production') {
+        console.warn('Socket context is empty.');
+      }
+
+      return function () {};
+    }
+
+    var wasStarted = socket.isStarted();
+
+    var onStarted = function onStarted() {
+      return setStarted(true);
+    };
+
+    var onStop = function onStop() {
+      return setStarted(false);
+    };
+
+    socket.on('stop', onStop);
+    socket.on('started', onStarted);
+
+    if (channels !== null) {
+      subscribe(channels);
+    }
+
+    if (!wasStarted) {
+      socket.start();
+    }
+
+    return function () {
+      socket.off('stop', onStop);
+      socket.off('started', onStarted);
+
+      if (channels !== null) {
+        unsubscribe(channels);
+      }
+
+      if (!wasStarted) {
+        socket.stop();
+      }
+    };
+  }, [channelsKey, customSocket]);
+  useEffect(function () {
+    if (socket === null) {
+      return function () {};
+    }
+
+    var onMessage = function onMessage() {
+      if (customOnMessage !== null) {
+        customOnMessage.apply(void 0, arguments);
+      }
+    };
+
+    socket.on('message', onMessage);
+    return function () {
+      socket.off('message', onMessage);
+    };
+  }, [customOnMessage]);
+  return {
+    socket: socket,
+    started: started,
+    subscribe: subscribe,
+    unsubscribe: unsubscribe
+  };
+};
+
+export { Socket, SocketContainer, SocketContext, Socket as default, useSocket, withSocket };