@folklore/socket 0.4.16 → 0.4.18

package/dist/es.js

@@ -8,8 +8,7 @@ import PropTypes from 'prop-types';
 import { jsx } from 'react/jsx-runtime';
 import isString from 'lodash/isString';
 
-const debug$2 = createDebug('folklore:socket:pubnub');
-
+const debug$3 = createDebug('folklore:socket:pubnub');
 class PubNubSocket extends EventEmitter {
   constructor(opts) {
     super();
@@ -34,16 +33,13 @@ class PubNubSocket extends EventEmitter {
     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;
@@ -51,51 +47,42 @@ class PubNubSocket extends EventEmitter {
       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');
+    debug$3('Load PubNub');
     return import('pubnub').then(_ref2 => {
       let {
         default: PubNub
@@ -103,12 +90,10 @@ class PubNubSocket extends EventEmitter {
       this.PubNub = PubNub;
     });
   }
-
   createPubNub() {
     if (this.destroyed) {
       return;
     }
-
     const {
       PubNub
     } = this;
@@ -116,15 +101,12 @@ class PubNubSocket extends EventEmitter {
       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,
@@ -132,38 +114,31 @@ class PubNubSocket extends EventEmitter {
     };
     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({
@@ -171,13 +146,11 @@ class PubNubSocket extends EventEmitter {
     });
     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;
@@ -186,13 +159,12 @@ class PubNubSocket extends EventEmitter {
     });
     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,
@@ -203,11 +175,9 @@ class PubNubSocket extends EventEmitter {
       });
     });
   }
-
 }
 
-const debug$1 = createDebug('folklore:socket:socketio');
-
+const debug$2 = createDebug('folklore:socket:socketio');
 class SocketIOSocket extends EventEmitter {
   constructor(opts) {
     super();
@@ -231,27 +201,22 @@ class SocketIOSocket extends EventEmitter {
     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() {
     import('socket.io-client').then(_ref => {
       let {
@@ -264,7 +229,6 @@ class SocketIOSocket extends EventEmitter {
       }
     });
   }
-
   createManager() {
     const {
       Manager
@@ -278,96 +242,82 @@ class SocketIOSocket extends EventEmitter {
       ...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,
@@ -379,46 +329,207 @@ class SocketIOSocket extends EventEmitter {
     });
     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('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 = {
@@ -443,139 +554,110 @@ class Socket extends EventEmitter {
     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,
@@ -586,7 +668,7 @@ class Socket extends EventEmitter {
     this.adapter = new SocketAdapter(adapterOptions);
     const methods = ['start', 'stop', 'destroy', 'updateChannels', 'send'];
     methods.forEach(method => {
-      invariant(isFunction(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);
@@ -595,70 +677,57 @@ class Socket extends EventEmitter {
     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
@@ -666,14 +735,12 @@ class Socket extends EventEmitter {
     debug('Sending', publishData);
     return this.adapter.send(publishData);
   }
-
   isStarted() {
     return this.started;
   }
-
 }
-
-Socket.adapters = { ...SocketAdapters
+Socket.adapters = {
+  ...SocketAdapters
 };
 
 const SocketContext = /*#__PURE__*/React.createContext({
@@ -708,8 +775,7 @@ const defaultProps = {
   autoStart: false,
   children: null
 };
-
-const SocketContainer = function (_ref) {
+function SocketContainer(_ref) {
   let {
     children,
     socket,
@@ -721,9 +787,11 @@ const SocketContainer = function (_ref) {
     publishKey,
     subscribeKey,
     secretKey,
-    channels: initialChannels
+    channels: initialChannels,
+    ...props
   } = _ref;
   const finalSocket = useMemo(() => socket || new Socket({
+    ...props,
     adapter,
     host,
     namespace,
@@ -739,7 +807,8 @@ const SocketContainer = function (_ref) {
     setChannels(newChannels);
   }, [finalSocket, setChannels]);
   const addToChannelsCount = 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));
@@ -747,7 +816,8 @@ const SocketContainer = function (_ref) {
   const removeToChannelsCount = 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);
@@ -763,11 +833,9 @@ const SocketContainer = function (_ref) {
   }, [initialChannels, subscribe, unsubscribe]);
   useEffect(() => {
     finalSocket.init();
-
     if (autoStart) {
       finalSocket.start();
     }
-
     return () => {
       finalSocket.destroy();
     };
@@ -782,13 +850,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__*/jsx(SocketContext.Consumer, {
     children: _ref => {
@@ -805,8 +871,7 @@ const withSocket = WrappedComponent => {
       });
     }
   });
-
-  WithSocketComponent.displayName = "WithSocket(".concat(getDisplayName(WrappedComponent), ")");
+  WithSocketComponent.displayName = `WithSocket(${getDisplayName(WrappedComponent)})`;
   return WithSocketComponent;
 };
 
@@ -830,35 +895,25 @@ const useSocket = function () {
       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();
       }
@@ -868,13 +923,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);