@trap_stevo/legendarybuilderproreact-ui/dist/HUDComponents/HUDSocketProvider.js

The legendary UI & utility API that makes your application a legendary application. ~ Created by Steven Compton

import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _regeneratorRuntime from "@babel/runtime/regenerator";
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
import React, { createContext, useContext, useEffect, useRef, useState, useCallback } from "react";
import io from "socket.io-client";
var SocketContext = /*#__PURE__*/createContext();
export var HUDSocketProvider = function HUDSocketProvider(_ref) {
  var children = _ref.children,
    serverURL = _ref.serverURL,
    _ref$options = _ref.options,
    options = _ref$options === void 0 ? {} : _ref$options;
  var _useState = useState(0),
    _useState2 = _slicedToArray(_useState, 2),
    reconnectionAttempts = _useState2[0],
    setReconnectionAttempts = _useState2[1];
  var _useState3 = useState(new Set()),
    _useState4 = _slicedToArray(_useState3, 2),
    registeredEvents = _useState4[0],
    setRegisteredEvents = _useState4[1];
  var _useState5 = useState(serverURL),
    _useState6 = _slicedToArray(_useState5, 2),
    currentServerURL = _useState6[0],
    setCurrentServerURL = _useState6[1];
  var _useState7 = useState(false),
    _useState8 = _slicedToArray(_useState7, 2),
    connected = _useState8[0],
    setConnected = _useState8[1];
  var socketRef = useRef(null);
  var registerEvent = useCallback(function (event, handler) {
    if (socketRef.current) {
      setRegisteredEvents(function (prevR) {
        return new Set(prevR).add(event);
      });
      socketRef.current.on(event, handler);
    }
  }, []);
  var sendData = useCallback(function (event, data) {
    if (socketRef.current) {
      socketRef.current.emit(event, data);
    }
  }, []);
  var deregisterEvent = useCallback(function (event) {
    if (socketRef.current && registeredEvents.has(event)) {
      socketRef.current.off(event);
      setRegisteredEvents(function (prevR) {
        var updatedRegisteredEvents = new Set(prevR);
        updatedRegisteredEvents["delete"](event);
        return updatedRegisteredEvents;
      });
    }
  }, []);
  var createNetSocket = useCallback(function () {
    var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : currentServerURL;
    var connectionOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : options;
    if (url === undefined) {
      return null;
    }
    var currentSocket = io(url, _objectSpread({
      autoConnect: true
    }, connectionOptions));
    window.electron.logSystemMessage("Socketing into network with: " + currentServerURL);
    socketRef.current = currentSocket;
    currentSocket.on("connect", function () {
      console.log("Connected to the signaling server.");
      setConnected(true);
      setReconnectionAttempts(0);
    });
    currentSocket.on("disconnect", function (reason) {
      console.log("Disconnected from the signaling server: ", reason);
      setConnected(false);
    });
    currentSocket.on("reconnect_attempt", function () {
      setReconnectionAttempts(function (prev) {
        return prev + 1;
      });
      console.log("Reconnecting (".concat(reconnectionAttempts, ")"));
    });
    currentSocket.on("connect_error", function (error) {
      console.error("Connection error: ", error);
    });
    currentSocket.on("reconnect_failed", function () {
      console.error("Did not reconnect after multiple attempts.");
    });
    return currentSocket;
  }, [currentServerURL]);
  var updateServerURL = useCallback( /*#__PURE__*/function () {
    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(url) {
      return _regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) switch (_context.prev = _context.next) {
          case 0:
            if (socketRef.current) {
              socketRef.current.disconnect();
            }
            setCurrentServerURL(url);
            createNetSocket(url);
            return _context.abrupt("return");
          case 4:
          case "end":
            return _context.stop();
        }
      }, _callee);
    }));
    return function (_x) {
      return _ref2.apply(this, arguments);
    };
  }(), [createNetSocket]);
  useEffect(function () {
    var connectedSocket = createNetSocket();
    return function () {
      if (connectedSocket) {
        registeredEvents.forEach(function (event) {
          if (connectedSocket) {
            connectedSocket.off(event);
          }
        });
        setRegisteredEvents(new Set());
        connectedSocket.close();
      }
    };
  }, [createNetSocket]);
  return /*#__PURE__*/React.createElement(SocketContext.Provider, {
    value: {
      socket: socketRef.current,
      socketState: socketRef,
      connected: connected,
      registerEvent: registerEvent,
      deregisterEvent: deregisterEvent,
      sendData: sendData,
      createNetSocket: createNetSocket,
      updateServerURL: updateServerURL
    }
  }, children);
};
export var useHUDSocket = function useHUDSocket() {
  var context = useContext(SocketContext);
  if (!context) {
    console.error("Must use within HUDSocketProvider.");
  }
  return context;
};