@folklore/socket 0.4.30 → 0.4.32

package/dist/cjs.js

@@ -1,961 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var createDebug = require('debug');
-var invariant = require('invariant');
-var isFunction = require('lodash/isFunction');
-var EventEmitter = require('wolfy87-eventemitter');
-var isString = require('lodash/isString');
-var isArray = require('lodash/isArray');
-var React = require('react');
-var PropTypes = require('prop-types');
-var jsxRuntime = require('react/jsx-runtime');
-
-const debug$3 = createDebug('folklore:socket:pubnub');
-class PubNubSocket extends EventEmitter {
-  constructor(opts) {
-    super();
-    this.options = {
-      uuid: null,
-      publishKey: null,
-      subscribeKey: null,
-      secretKey: null,
-      userId: null,
-      withPresence: false,
-      ...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();
-  }
-  onReady() {
-    if (this.destroyed) {
-      return;
-    }
-    this.ready = true;
-    this.emit('ready');
-  }
-  onStatus(statusEvent) {
-    if (statusEvent.category === 'PNConnectedCategory' && !this.started) {
-      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$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$3('Init');
-    this.destroyed = false;
-    const loadPubnub = this.PubNub !== null ? Promise.resolve() : this.loadPubNub();
-    loadPubnub.then(() => this.createPubNub()).then(() => this.onReady());
-  }
-  loadPubNub() {
-    debug$3('Load PubNub');
-    return import('pubnub').then(({
-      default: PubNub
-    }) => {
-      this.PubNub = PubNub;
-    });
-  }
-  createPubNub() {
-    if (this.destroyed) {
-      return;
-    }
-    const {
-      PubNub
-    } = this;
-    const pubnubOptions = {
-      publishKey: this.options.publishKey,
-      subscribeKey: this.options.subscribeKey,
-      userId: `web-user-${Math.floor(Math.random() * 1000)}`
-    };
-    if (this.options.uuid !== null) {
-      pubnubOptions.uuid = this.options.uuid;
-    }
-    if (this.options.userId !== null) {
-      pubnubOptions.userId = this.options.userId;
-    }
-    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);
-  }
-  destroy() {
-    this.destroyed = true;
-    this.stop();
-    if (this.pubnubListener) {
-      this.pubnub.removeListener(this.pubnubListener);
-      this.pubnubListener = null;
-    }
-    this.pubnub = null;
-    this.ready = false;
-    debug$3('Destroyed.');
-  }
-  start() {
-    if (this.started) {
-      debug$3('Skipping start: Already started.');
-      return;
-    }
-    if (this.starting) {
-      debug$3('Skipping start: Already starting.');
-      return;
-    }
-    if (this.channels.length === 0) {
-      debug$3('Skipping start: No channels.');
-      this.shouldStart = true;
-      return;
-    }
-    const {
-      subscriptionOptions,
-      withPresence
-    } = this.options;
-    this.shouldStart = false;
-    this.starting = true;
-    this.pubnub.subscribe({
-      channels: this.channels,
-      subscriptionOptions,
-      withPresence
-    });
-    this.emit('start');
-  }
-  stop() {
-    if (!this.started && !this.starting) {
-      return;
-    }
-    debug$3('Stopping...');
-    this.shouldStart = false;
-    this.started = false;
-    this.starting = false;
-    this.pubnub.unsubscribe({
-      channels: this.channels
-    });
-    this.emit('stop');
-  }
-  send(data) {
-    debug$3('Sending', data);
-    return new Promise((resolve, reject) => {
-      this.pubnub.publish(data, (status, response) => {
-        if (status.error) {
-          reject(new Error(`Error operation:${status.operation} status:${status.statusCode}`));
-        } else {
-          resolve({
-            status,
-            response,
-            data
-          });
-        }
-      });
-    });
-  }
-}
-
-const debug$2 = createDebug('folklore:socket:socketio');
-class SocketIOSocket extends EventEmitter {
-  constructor(opts) {
-    super();
-    this.options = {
-      uuid: null,
-      host: 'http://127.0.0.1',
-      path: null,
-      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();
-  }
-  onReady() {
-    this.ready = true;
-    this.emit('ready');
-  }
-  onConnect(channel) {
-    debug$2('Socket connected on %s', channel);
-    if (!this.started) {
-      this.started = true;
-      this.starting = false;
-      this.emit('started');
-    }
-  }
-  onMessage(message, channel) {
-    debug$2('Message received on %s %o', channel, message);
-    this.emit('message', message, channel);
-  }
-  init() {
-    import('socket.io-client').then(({
-      default: IO
-    }) => {
-      this.Manager = IO.Manager;
-    }).then(() => this.createManager()).then(() => this.onReady()).then(() => {
-      if (this.shouldStart) {
-        this.start();
-      }
-    });
-  }
-  createManager() {
-    const {
-      Manager
-    } = this;
-    const {
-      host,
-      ...opts
-    } = this.options;
-    this.io = new Manager(host, {
-      autoConnect: false,
-      ...opts
-    });
-  }
-  updateChannels(channels) {
-    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$2('Skipping start: Already started.');
-      return;
-    }
-    if (this.starting) {
-      debug$2('Skipping start: Already starting.');
-      return;
-    }
-    if (this.io === null) {
-      debug$2('Socket.io not ready.');
-      this.shouldStart = true;
-      return;
-    }
-    if (this.channels.length === 0) {
-      debug$2('Skipping start: No channels.');
-      this.shouldStart = true;
-      return;
-    }
-    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;
-    }
-    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(`/${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
-  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(channel) ? [channel] : channel;
-    channels.forEach(ch => {
-      this.sockets[ch].send(message);
-    });
-    return Promise.resolve();
-  }
-}
-
-const debug$1 = createDebug('folklore:socket:pusher');
-class PusherSocket 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 Pusher');
-    return import('pusher-js').then(({
-      default: Pusher
-    }) => {
-      this.Pusher = Pusher;
-    });
-  }
-  createPusher() {
-    if (this.destroyed) {
-      return;
-    }
-    debug$1('Create Pusher appKey: %s', this.options.appKey);
-    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.pusher === 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,
-  Pusher: PusherSocket
-};
-
-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 ${adapter} not found`);
-    }
-    return Socket.adapters[adapterKey];
-  }
-  static addAdapter(name, adapter) {
-    Socket.adapters = {
-      ...Socket.adapters,
-      [name]: adapter
-    };
-    return Socket;
-  }
-  static setAdapters(adapters) {
-    Socket.adapters = adapters;
-    return Socket;
-  }
-  constructor(opts) {
-    super();
-    this.options = {
-      adapter: 'pubnub',
-      namespace: null,
-      uuid: null,
-      publishKey: null,
-      subscribeKey: null,
-      secretKey: null,
-      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);
-    }
-  }
-  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(`^${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: ${namespacedChannels.join(', ')}`);
-    this.updateChannels(namespacedChannels);
-  }
-  addChannel(channel) {
-    const namespacedChannel = this.getChannelWithNamespace(channel);
-    if (this.channels.indexOf(namespacedChannel) !== -1) {
-      return;
-    }
-    debug(`Adding channel: ${channel}`);
-    this.updateChannels([...this.channels, namespacedChannel]);
-  }
-  addChannels(channels) {
-    const namespacedChannels = channels.map(channel => this.getChannelWithNamespace(channel)).sort();
-    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: ${channel}`);
-    this.updateChannels(this.channels.filter(ch => ch !== namespacedChannel));
-  }
-  removeChannels(channels) {
-    const namespacedChannels = channels.map(channel => this.getChannelWithNamespace(channel)).sort();
-    debug(`Removing channels: ${channels.join(',')}`);
-    this.updateChannels(this.channels.filter(it => namespacedChannels.indexOf(it) === -1));
-  }
-  updateChannels(channels) {
-    const sortedChannels = channels.sort();
-    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,
-      channels,
-      ...adapterOptions
-    } = this.options;
-    const SocketAdapter = isString(adapterKey) ? Socket.getAdapter(adapterKey) : adapterKey;
-    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 ${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);
-    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(`- ${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
-    };
-    debug('Sending', publishData);
-    return this.adapter.send(publishData);
-  }
-  isStarted() {
-    return this.started;
-  }
-}
-Socket.adapters = {
-  ...SocketAdapters
-};
-
-const SocketContext = /*#__PURE__*/React.createContext({
-  socket: null,
-  subscribe: () => {},
-  unsubscribe: () => {}
-});
-
-const 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
-};
-const defaultProps = {
-  socket: null,
-  adapter: 'pubnub',
-  host: null,
-  namespace: null,
-  uuid: null,
-  publishKey: null,
-  subscribeKey: null,
-  secretKey: null,
-  channels: [],
-  autoStart: false,
-  children: null
-};
-function SocketContainer({
-  children,
-  socket,
-  autoStart,
-  adapter,
-  host,
-  namespace,
-  uuid,
-  publishKey,
-  subscribeKey,
-  secretKey,
-  channels: initialChannels,
-  ...props
-}) {
-  const finalSocket = React.useMemo(() => socket || new Socket({
-    ...props,
-    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]);
-  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]);
-  const removeToChannelsCount = React.useCallback(newChannels => {
-    channelsCountRef.current = newChannels.reduce((map, channel) => {
-      const {
-        [channel]: currentCount = 0,
-        ...otherCount
-      } = map;
-      const newCount = (currentCount || 0) - 1;
-      return newCount > 0 ? {
-        ...otherCount,
-        [channel]: newCount
-      } : otherCount;
-    }, channelsCountRef.current);
-    updateChannels(Object.keys(channelsCountRef.current));
-  }, [updateChannels]);
-  const subscribe = React.useCallback(channelsToAdd => addToChannelsCount(channelsToAdd), [addToChannelsCount]);
-  const unsubscribe = React.useCallback(channelsToRemove => removeToChannelsCount(channelsToRemove), [removeToChannelsCount]);
-  React.useEffect(() => {
-    subscribe(initialChannels);
-    return () => {
-      unsubscribe(initialChannels);
-    };
-  }, [initialChannels, subscribe, unsubscribe]);
-  React.useEffect(() => {
-    finalSocket.init();
-    if (autoStart) {
-      finalSocket.start();
-    }
-    return () => {
-      finalSocket.destroy();
-    };
-  }, [autoStart, finalSocket]);
-  const value = React.useMemo(() => ({
-    socket: finalSocket,
-    subscribe,
-    unsubscribe,
-    channels
-  }), [finalSocket, subscribe]);
-  return /*#__PURE__*/jsxRuntime.jsx(SocketContext.Provider, {
-    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: ({
-      socket,
-      subscribe,
-      unsubscribe
-    }) => /*#__PURE__*/jsxRuntime.jsx(WrappedComponent, {
-      socket: socket,
-      socketSubscribe: subscribe,
-      socketUnsubscribe: unsubscribe,
-      ...props
-    })
-  });
-  WithSocketComponent.displayName = `WithSocket(${getDisplayName(WrappedComponent)})`;
-  return WithSocketComponent;
-};
-
-const useSocket = (channelNames = null, {
-  socket: customSocket = null,
-  onMessage: customOnMessage = null,
-  keepAlive = true
-} = {}) => {
-  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(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 (socket.isStarted() && !keepAlive) {
-        socket.stop();
-      }
-    };
-  }, [channelsKey, customSocket, keepAlive]);
-  React.useEffect(() => {
-    if (socket === null) {
-      return () => {};
-    }
-    const onMessage = (...args) => {
-      if (customOnMessage !== null) {
-        customOnMessage(...args);
-      }
-    };
-    socket.on('message', onMessage);
-    return () => {
-      socket.off('message', onMessage);
-    };
-  }, [customOnMessage]);
-  return {
-    socket,
-    started,
-    subscribe,
-    unsubscribe
-  };
-};
-
-exports.Socket = Socket;
-exports.SocketContainer = SocketContainer;
-exports.SocketContext = SocketContext;
-exports.default = Socket;
-exports.useSocket = useSocket;
-exports.withSocket = withSocket;