@folklore/socket 0.4.16 → 0.4.18

package/dist/cjs.js

@@ -12,38 +12,8 @@ var PropTypes = require('prop-types');
 var jsxRuntime = require('react/jsx-runtime');
 var isString = require('lodash/isString');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n["default"] = e;
-    return Object.freeze(n);
-}
-
-var createDebug__default = /*#__PURE__*/_interopDefaultLegacy(createDebug);
-var invariant__default = /*#__PURE__*/_interopDefaultLegacy(invariant);
-var isFunction__default = /*#__PURE__*/_interopDefaultLegacy(isFunction);
-var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
-var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
-var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
-
-const debug$2 = createDebug__default["default"]('folklore:socket:pubnub');
-
-class PubNubSocket extends EventEmitter__default["default"] {
+const debug$3 = createDebug('folklore:socket:pubnub');
+class PubNubSocket extends EventEmitter {
   constructor(opts) {
     super();
     this.options = {
@@ -67,16 +37,13 @@ class PubNubSocket extends EventEmitter__default["default"] {
     this.channels = [];
     this.init();
   }
-
   onReady() {
     if (this.destroyed) {
       return;
     }
-
     this.ready = true;
     this.emit('ready');
   }
-
   onStatus(statusEvent) {
     if (statusEvent.category === 'PNConnectedCategory' && !this.started) {
       this.started = true;
@@ -84,64 +51,53 @@ class PubNubSocket extends EventEmitter__default["default"] {
       this.emit('started');
     }
   }
-
   onMessage(_ref) {
     let {
       message
     } = _ref;
     this.emit('message', message);
-
     if (typeof message.event !== 'undefined') {
       this.emit(message.event, message.data || message);
     }
   }
-
   updateChannels(channels) {
-    debug$2("Updating channels: ".concat(channels.join(', ')));
+    debug$3(`Updating channels: ${channels.join(', ')}`);
     const {
       shouldStart,
       started,
       starting
     } = this;
-
     if (started || starting) {
       this.stop();
     }
-
     this.channels = channels;
-
     if (started || starting || shouldStart) {
       this.shouldStart = false;
       this.start();
     }
   }
-
   init() {
     if (this.pubnub !== null) {
       return;
     }
-
-    debug$2('Init');
+    debug$3('Init');
     this.destroyed = false;
     const loadPubnub = this.PubNub !== null ? Promise.resolve() : this.loadPubNub();
     loadPubnub.then(() => this.createPubNub()).then(() => this.onReady());
   }
-
   loadPubNub() {
-    debug$2('Load PubNub');
-    return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('pubnub')); }).then(_ref2 => {
+    debug$3('Load PubNub');
+    return import('pubnub').then(_ref2 => {
       let {
         default: PubNub
       } = _ref2;
       this.PubNub = PubNub;
     });
   }
-
   createPubNub() {
     if (this.destroyed) {
       return;
     }
-
     const {
       PubNub
     } = this;
@@ -149,15 +105,12 @@ class PubNubSocket extends EventEmitter__default["default"] {
       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,
@@ -165,38 +118,31 @@ class PubNubSocket extends EventEmitter__default["default"] {
     };
     this.pubnub.addListener(this.pubnubListener);
   }
-
   destroy() {
     this.destroyed = true;
     this.stop();
-
     if (this.pubnubListener) {
       this.pubnub.removeListener(this.pubnubListener);
       this.pubnubListener = null;
     }
-
     this.pubnub = null;
     this.ready = false;
-    debug$2('Destroyed.');
+    debug$3('Destroyed.');
   }
-
   start() {
     if (this.started) {
-      debug$2('Skipping start: Already started.');
+      debug$3('Skipping start: Already started.');
       return;
     }
-
     if (this.starting) {
-      debug$2('Skipping start: Already starting.');
+      debug$3('Skipping start: Already starting.');
       return;
     }
-
     if (this.channels.length === 0) {
-      debug$2('Skipping start: No channels.');
+      debug$3('Skipping start: No channels.');
       this.shouldStart = true;
       return;
     }
-
     this.shouldStart = false;
     this.starting = true;
     this.pubnub.subscribe({
@@ -204,13 +150,11 @@ class PubNubSocket extends EventEmitter__default["default"] {
     });
     this.emit('start');
   }
-
   stop() {
     if (!this.started && !this.starting) {
       return;
     }
-
-    debug$2('Stopping...');
+    debug$3('Stopping...');
     this.shouldStart = false;
     this.started = false;
     this.starting = false;
@@ -219,13 +163,12 @@ class PubNubSocket extends EventEmitter__default["default"] {
     });
     this.emit('stop');
   }
-
   send(data) {
-    debug$2('Sending', data);
+    debug$3('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)));
+          reject(new Error(`Error operation:${status.operation} status:${status.statusCode}`));
         } else {
           resolve({
             status,
@@ -236,12 +179,10 @@ class PubNubSocket extends EventEmitter__default["default"] {
       });
     });
   }
-
 }
 
-const debug$1 = createDebug__default["default"]('folklore:socket:socketio');
-
-class SocketIOSocket extends EventEmitter__default["default"] {
+const debug$2 = createDebug('folklore:socket:socketio');
+class SocketIOSocket extends EventEmitter {
   constructor(opts) {
     super();
     this.options = {
@@ -264,29 +205,24 @@ class SocketIOSocket extends EventEmitter__default["default"] {
     this.channels = [];
     this.init();
   }
-
   onReady() {
     this.ready = true;
     this.emit('ready');
   }
-
   onConnect(channel) {
-    debug$1('Socket connected on %s', channel);
-
+    debug$2('Socket connected on %s', channel);
     if (!this.started) {
       this.started = true;
       this.starting = false;
       this.emit('started');
     }
   }
-
   onMessage(message, channel) {
-    debug$1('Message received on %s %o', channel, message);
+    debug$2('Message received on %s %o', channel, message);
     this.emit('message', message, channel);
   }
-
   init() {
-    Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('socket.io-client')); }).then(_ref => {
+    import('socket.io-client').then(_ref => {
       let {
         default: IO
       } = _ref;
@@ -297,7 +233,6 @@ class SocketIOSocket extends EventEmitter__default["default"] {
       }
     });
   }
-
   createManager() {
     const {
       Manager
@@ -311,147 +246,294 @@ class SocketIOSocket extends EventEmitter__default["default"] {
       ...opts
     });
   }
-
   updateChannels(channels) {
-    debug$1("Updating channels: ".concat(channels.join(', ')));
+    debug$2(`Updating channels: ${channels.join(', ')}`);
     const {
       shouldStart,
       started,
       starting
     } = this;
-
     if (started || starting) {
       this.stop();
     }
-
     this.channels = channels;
-
     if (started || starting || shouldStart) {
       this.start();
     }
   }
-
   start() {
     if (this.started) {
-      debug$1('Skipping start: Already started.');
+      debug$2('Skipping start: Already started.');
       return;
     }
-
     if (this.starting) {
-      debug$1('Skipping start: Already starting.');
+      debug$2('Skipping start: Already starting.');
       return;
     }
-
     if (this.io === null) {
-      debug$1('Socket.io not ready.');
+      debug$2('Socket.io not ready.');
       this.shouldStart = true;
       return;
     }
-
     if (this.channels.length === 0) {
-      debug$1('Skipping start: No channels.');
+      debug$2('Skipping start: No channels.');
       this.shouldStart = true;
       return;
     }
-
     this.shouldStart = false;
     this.starting = true;
-    this.sockets = this.channels.reduce((map, channel) => ({ ...map,
+    this.sockets = this.channels.reduce((map, channel) => ({
+      ...map,
       [channel]: this.createSocket(channel)
     }), {});
     this.emit('start');
   }
-
   stop() {
     if (!this.started && !this.starting) {
       return;
     }
-
-    debug$1('Stopping...');
+    debug$2('Stopping...');
     this.shouldStart = false;
     this.started = false;
     this.starting = false;
     Object.values(this.sockets).forEach(socket => this.stopSocket(socket));
     this.emit('stop');
   }
-
   createSocket(channel) {
-    const socket = this.io.socket("/".concat(channel.replace(/^\//, '')));
+    const socket = this.io.socket(`/${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
-
+  }
 
+  // eslint-disable-next-line class-methods-use-this
   stopSocket(socket) {
     socket.off('connect');
     socket.off('message');
     socket.close();
     return socket;
   }
-
   destroy() {
     this.stop();
     this.sockets = {};
-
     if (this.io !== null) {
       this.io.close();
       this.io = null;
     }
   }
-
   send(data) {
     const {
       channel,
       message
     } = data;
-    const channels = !isArray__default["default"](channel) ? [channel] : channel;
+    const channels = !isArray(channel) ? [channel] : channel;
     channels.forEach(ch => {
       this.sockets[ch].send(message);
     });
     return Promise.resolve();
   }
+}
+
+const debug$1 = createDebug('folklore:socket:pusher');
+class PusherSocker extends EventEmitter {
+  constructor(opts) {
+    super();
+    this.options = {
+      uuid: null,
+      publishKey: null,
+      subscribeKey: null,
+      secretKey: null,
+      ...opts
+    };
+    this.onReady = this.onReady.bind(this);
+    this.onConnected = this.onConnected.bind(this);
+    this.onMessage = this.onMessage.bind(this);
+    this.destroyed = false;
+    this.ready = false;
+    this.shouldStart = false;
+    this.started = false;
+    this.starting = false;
+    this.Pusher = null;
+    this.pusher = null;
+    this.channels = [];
+    this.clients = {};
+    this.init();
+  }
+  onReady() {
+    if (this.destroyed) {
+      return;
+    }
+    this.ready = true;
+    this.emit('ready');
+  }
+  onConnected() {
+    this.started = true;
+    this.starting = false;
+    this.emit('started');
+  }
+  onMessage(message) {
+    this.emit('message', message);
+    if (typeof message.event !== 'undefined') {
+      this.emit(message.event, message.data || message);
+    }
+  }
+  updateChannels(channels) {
+    debug$1(`Updating channels: ${channels.join(', ')}`);
+    const {
+      shouldStart,
+      started,
+      starting
+    } = this;
+    if (started || starting) {
+      this.stop();
+    }
+    this.channels = channels;
+    if (started || starting || shouldStart) {
+      this.shouldStart = false;
+      this.start();
+    }
+  }
+  init() {
+    if (this.pusher !== null) {
+      return;
+    }
+    debug$1('Init');
+    this.destroyed = false;
+    const loadPusher = this.Pusher !== null ? Promise.resolve() : this.loadPusher();
+    loadPusher.then(() => this.createPusher()).then(() => this.onReady());
+  }
+  loadPusher() {
+    debug$1('Load PusherJs');
+    return import('pusher-js').then(_ref => {
+      let {
+        default: Pusher
+      } = _ref;
+      this.Pusher = Pusher;
+    });
+  }
+  createPusher() {
+    if (this.destroyed) {
+      return;
+    }
+    const {
+      Pusher
+    } = this;
+    const {
+      appKey,
+      ...options
+    } = this.options;
+    this.pusher = new Pusher(appKey, options);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.stop();
+    this.pusher = null;
+    this.clients = {};
+    this.ready = false;
+    debug$1('Destroyed.');
+  }
+  start() {
+    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.pusher.connection.bind('connected', this.onConnected);
+    this.clients = this.channels.reduce((map, channel) => ({
+      ...map,
+      [channel]: this.createClient(channel)
+    }), {});
+    this.emit('start');
+  }
+  stop() {
+    if (!this.started && !this.starting) {
+      return;
+    }
+    debug$1('Stopping...');
+    this.shouldStart = false;
+    this.started = false;
+    this.starting = false;
+    this.pusher.connection.unbind('connected');
+    Object.keys(this.clients).forEach(channelName => this.stopClient(channelName, this.clients[channelName]));
+    this.clients = {};
+    this.emit('stop');
+  }
+  createClient(channelName) {
+    const channel = this.pusher.subscribe(channelName);
+    channel.bind_global((event, data) => this.onMessage({
+      event,
+      data
+    }, channel));
+    return channel;
+  }
 
+  // eslint-disable-next-line class-methods-use-this
+  stopClient(channelName, channel) {
+    channel.unbind_global();
+    this.pusher.unsubscribe(channelName);
+    return channel;
+  }
+  send(data) {
+    debug$1('Sending', data);
+    return new Promise(resolve => {
+      const {
+        channel,
+        event = null,
+        data: eventData
+      } = data;
+      this.pusher.trigger(channel, event || 'message', eventData);
+      resolve();
+    });
+  }
 }
 
 var SocketAdapters = {
   PubNub: PubNubSocket,
-  SocketIO: SocketIOSocket
+  SocketIO: SocketIOSocket,
+  Pusher: PusherSocker
 };
 
 const normalize = str => str.replace(/[^a-z0-9]+/gi, '').toLowerCase();
-
-const debug = createDebug__default["default"]('folklore:socket');
-
-class Socket extends EventEmitter__default["default"] {
+const debug = createDebug('folklore:socket');
+class Socket extends EventEmitter {
   static getAdapters() {
     return Socket.adapters;
   }
-
   static getAdapter(adapter) {
     // prettier-ignore
     const adapterKey = Object.keys(Socket.adapters).find(key => normalize(key) === normalize(adapter)) || null;
-
     if (adapterKey === null) {
-      throw new Error("Adapter ".concat(adapter, " not found"));
+      throw new Error(`Adapter ${adapter} not found`);
     }
-
     return Socket.adapters[adapterKey];
   }
-
   static addAdapter(name, adapter) {
-    Socket.adapters = { ...Socket.adapters,
+    Socket.adapters = {
+      ...Socket.adapters,
       [name]: adapter
     };
     return Socket;
   }
-
   static setAdapters(adapters) {
     Socket.adapters = adapters;
     return Socket;
   }
-
   constructor(opts) {
     super();
     this.options = {
@@ -476,139 +558,110 @@ class Socket extends EventEmitter__default["default"] {
     this.adapter = null;
     this.channels = [];
     this.init();
-
     if (this.options.channels.length) {
       this.setChannels(this.options.channels);
     }
   }
-
   onAdapterReady() {
     debug('Adapter ready');
     this.ready = true;
     this.emit('ready');
-
     if (this.shouldStart) {
       this.shouldStart = false;
       this.start();
     }
   }
-
   onAdapterStart() {
     debug('Adapter starting...');
     this.starting = true;
     this.started = false;
     this.emit('start');
   }
-
   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);
   }
-
   getChannelWithoutNamespace(name) {
     if (this.options.namespace === null) {
       return name;
     }
-
-    const regExp = new RegExp("^".concat(this.options.namespace, ":"));
+    const regExp = new RegExp(`^${this.options.namespace}:`);
     return name.replace(regExp, '');
   }
-
   getChannelWithNamespace(name) {
     const parts = [];
-
     if (this.options.namespace !== null) {
       parts.push(this.options.namespace);
     }
-
     parts.push(name);
     return parts.join(':');
   }
-
   setChannels(channels) {
     const namespacedChannels = channels.map(channel => this.getChannelWithNamespace(channel)).sort();
-
     if (this.channels.join(',') === namespacedChannels.join(',')) {
       return;
     }
-
-    debug("Set channels: ".concat(namespacedChannels.join(', ')));
+    debug(`Set channels: ${namespacedChannels.join(', ')}`);
     this.updateChannels(namespacedChannels);
   }
-
   addChannel(channel) {
     const namespacedChannel = this.getChannelWithNamespace(channel);
-
     if (this.channels.indexOf(namespacedChannel) !== -1) {
       return;
     }
-
-    debug("Adding channel: ".concat(channel));
+    debug(`Adding channel: ${channel}`);
     this.updateChannels([...this.channels, namespacedChannel]);
   }
-
   addChannels(channels) {
     const namespacedChannels = channels.map(channel => this.getChannelWithNamespace(channel)).sort();
-    debug("Adding channels: ".concat(channels.join(',')));
+    debug(`Adding channels: ${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;
     }
-
-    debug("Removing channel: ".concat(channel));
+    debug(`Removing channel: ${channel}`);
     this.updateChannels(this.channels.filter(ch => ch !== namespacedChannel));
   }
-
   removeChannels(channels) {
     const namespacedChannels = channels.map(channel => this.getChannelWithNamespace(channel)).sort();
-    debug("Removing channels: ".concat(channels.join(',')));
+    debug(`Removing channels: ${channels.join(',')}`);
     this.updateChannels(this.channels.filter(it => namespacedChannels.indexOf(it) === -1));
   }
-
   updateChannels(channels) {
     const sortedChannels = channels.sort();
-    debug("Updating channels: ".concat(sortedChannels.join(', ')));
+    debug(`Updating channels: ${sortedChannels.join(', ')}`);
     this.channels = [...sortedChannels];
-
     if (this.adapter !== null) {
       this.adapter.updateChannels(sortedChannels);
     }
   }
-
   hasChannel(channel) {
     const namespacedChannel = this.getChannelWithNamespace(channel);
     return this.channels.reduce((found, it) => found || it === namespacedChannel, false);
   }
-
   getChannels() {
     return this.channels.map(channel => this.getChannelWithoutNamespace(channel));
   }
-
   init() {
     if (this.adapter !== null) {
       debug('Already initialized');
       return;
     }
-
     debug('Init');
     const {
       adapter: adapterKey,
@@ -619,7 +672,7 @@ class Socket extends EventEmitter__default["default"] {
     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));
+      invariant(isFunction(this.adapter[method] || null), `Socket adapter should implement method ${method}`);
     });
     this.adapter.on('ready', this.onAdapterReady);
     this.adapter.on('start', this.onAdapterStart);
@@ -628,70 +681,57 @@ class Socket extends EventEmitter__default["default"] {
     this.adapter.on('stop', this.onAdapterStop);
     this.adapter.updateChannels(this.channels);
   }
-
   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.');
   }
-
   restart() {
     this.stop();
     this.start();
   }
-
   start() {
     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(channel => {
-      debug("- ".concat(this.getChannelWithoutNamespace(channel)));
+      debug(`- ${this.getChannelWithoutNamespace(channel)}`);
     });
     this.adapter.start();
   }
-
   stop() {
     this.shouldStart = false;
-
     if (!this.started && !this.starting) {
       return;
     }
-
     debug('Stopping...');
-
     if (this.adapter !== null) {
       this.adapter.stop();
     }
   }
-
   send(data, channel) {
     if (!this.started) {
       debug('Abort sending data: Not started');
       return Promise.reject();
     }
-
     const publishData = typeof data.channel !== 'undefined' && typeof data.message !== 'undefined' ? data : {
       channel: typeof channel !== 'undefined' ? this.getChannelWithNamespace(channel) : this.channels,
       message: data
@@ -699,34 +739,32 @@ class Socket extends EventEmitter__default["default"] {
     debug('Sending', publishData);
     return this.adapter.send(publishData);
   }
-
   isStarted() {
     return this.started;
   }
-
 }
-
-Socket.adapters = { ...SocketAdapters
+Socket.adapters = {
+  ...SocketAdapters
 };
 
-const SocketContext = /*#__PURE__*/React__default["default"].createContext({
+const SocketContext = /*#__PURE__*/React.createContext({
   socket: null,
   subscribe: () => {},
   unsubscribe: () => {}
 });
 
 const propTypes = {
-  socket: PropTypes__default["default"].instanceOf(Socket),
-  adapter: PropTypes__default["default"].string,
-  host: PropTypes__default["default"].string,
-  namespace: PropTypes__default["default"].string,
-  uuid: PropTypes__default["default"].string,
-  publishKey: PropTypes__default["default"].string,
-  subscribeKey: PropTypes__default["default"].string,
-  secretKey: PropTypes__default["default"].string,
-  channels: PropTypes__default["default"].arrayOf(PropTypes__default["default"].string),
-  autoStart: PropTypes__default["default"].bool,
-  children: PropTypes__default["default"].node
+  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
 };
 const defaultProps = {
   socket: null,
@@ -741,8 +779,7 @@ const defaultProps = {
   autoStart: false,
   children: null
 };
-
-const SocketContainer = function (_ref) {
+function SocketContainer(_ref) {
   let {
     children,
     socket,
@@ -754,9 +791,11 @@ const SocketContainer = function (_ref) {
     publishKey,
     subscribeKey,
     secretKey,
-    channels: initialChannels
+    channels: initialChannels,
+    ...props
   } = _ref;
   const finalSocket = React.useMemo(() => socket || new Socket({
+    ...props,
     adapter,
     host,
     namespace,
@@ -772,7 +811,8 @@ const SocketContainer = function (_ref) {
     setChannels(newChannels);
   }, [finalSocket, setChannels]);
   const addToChannelsCount = React.useCallback(newChannels => {
-    channelsCountRef.current = newChannels.reduce((map, channel) => ({ ...map,
+    channelsCountRef.current = newChannels.reduce((map, channel) => ({
+      ...map,
       [channel]: (map[channel] || 0) + 1
     }), channelsCountRef.current);
     updateChannels(Object.keys(channelsCountRef.current));
@@ -780,7 +820,8 @@ const SocketContainer = function (_ref) {
   const removeToChannelsCount = React.useCallback(newChannels => {
     channelsCountRef.current = newChannels.reduce((map, channel) => {
       const newCount = (map[channel] || 0) - 1;
-      return newCount > 0 ? { ...map,
+      return newCount > 0 ? {
+        ...map,
         [channel]: newCount
       } : map;
     }, channelsCountRef.current);
@@ -796,11 +837,9 @@ const SocketContainer = function (_ref) {
   }, [initialChannels, subscribe, unsubscribe]);
   React.useEffect(() => {
     finalSocket.init();
-
     if (autoStart) {
       finalSocket.start();
     }
-
     return () => {
       finalSocket.destroy();
     };
@@ -815,13 +854,11 @@ const SocketContainer = function (_ref) {
     value: value,
     children: children
   });
-};
-
+}
 SocketContainer.propTypes = propTypes;
 SocketContainer.defaultProps = defaultProps;
 
 const getDisplayName = WrappedComponent => WrappedComponent.displayName || WrappedComponent.name || 'Component';
-
 const withSocket = WrappedComponent => {
   const WithSocketComponent = props => /*#__PURE__*/jsxRuntime.jsx(SocketContext.Consumer, {
     children: _ref => {
@@ -838,8 +875,7 @@ const withSocket = WrappedComponent => {
       });
     }
   });
-
-  WithSocketComponent.displayName = "WithSocket(".concat(getDisplayName(WrappedComponent), ")");
+  WithSocketComponent.displayName = `WithSocket(${getDisplayName(WrappedComponent)})`;
   return WithSocketComponent;
 };
 
@@ -856,42 +892,32 @@ const useSocket = function () {
   } = 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 channels = isString(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 () => {};
     }
-
     const wasStarted = socket.isStarted();
-
     const onStarted = () => setStarted(true);
-
     const onStop = () => setStarted(false);
-
     socket.on('stop', onStop);
     socket.on('started', onStarted);
-
     if (channels !== null) {
       subscribe(channels);
     }
-
     if (!wasStarted) {
       socket.start();
     }
-
     return () => {
       socket.off('stop', onStop);
       socket.off('started', onStarted);
-
       if (channels !== null) {
         unsubscribe(channels);
       }
-
       if (!wasStarted) {
         socket.stop();
       }
@@ -901,13 +927,11 @@ const useSocket = function () {
     if (socket === null) {
       return () => {};
     }
-
     const onMessage = function () {
       if (customOnMessage !== null) {
         customOnMessage(...arguments);
       }
     };
-
     socket.on('message', onMessage);
     return () => {
       socket.off('message', onMessage);
@@ -924,6 +948,6 @@ const useSocket = function () {
 exports.Socket = Socket;
 exports.SocketContainer = SocketContainer;
 exports.SocketContext = SocketContext;
-exports["default"] = Socket;
+exports.default = Socket;
 exports.useSocket = useSocket;
 exports.withSocket = withSocket;