@webrtc-remote-control/react/dist/react.umd.js

Thin abstraction layer above peerjs that will let you be more productive at making WebRTC data channels based apps.

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('prop-types'), require('@webrtc-remote-control/core')) :
  typeof define === 'function' && define.amd ? define(['exports', 'react', 'prop-types', '@webrtc-remote-control/core'], factory) :
  (global = global || self, factory(global.webrtcRemoteControlReact = {}, global.react, global.propTypes, global.core));
})(this, (function (exports, React, PropTypes, core) {
  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

  var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
  var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);

  // eslint-disable-next-line import/no-extraneous-dependencies
  var MyContext = React.createContext();
  function Provider(_ref) {
    var children = _ref.children,
        sessionStorageKey = _ref.sessionStorageKey,
        humanErrors = _ref.humanErrors,
        mode = _ref.mode,
        masterPeerId = _ref.masterPeerId,
        init = _ref.init;
    var allowedMode = ["master", "remote"];

    if (!allowedMode.includes(mode)) {
      throw new Error("Unsupported \"" + mode + "\" mode. Only " + allowedMode.map(function (a) {
        return "\"" + a + "\"";
      }).join(", ") + " accepted.");
    }

    if (mode === "master" && masterPeerId) {
      console.log(typeof masterPeerId);
      throw new Error("`masterPeerId` prop not allowed in \"master\" mode - \"" + masterPeerId + "\" was passed.");
    }

    if (mode === "remote" && !masterPeerId) {
      throw new Error("`masterPeerId` prop required in \"remote\" mode.");
    }

    var utils = core.prepareUtils({
      sessionStorageKey: sessionStorageKey,
      humanErrors: humanErrors
    });
    var providerValue = React.useRef({
      peer: null,
      promise: null,
      mode: mode,
      masterPeerId: masterPeerId
    });
    React.useEffect(function () {
      // expose the following on the ref forwarded to the provider
      providerValue.current.mode = mode;
      providerValue.current.humanizeError = utils.humanizeError;

      if (mode === "master") {
        providerValue.current.isConnectionFromRemote = utils.isConnectionFromRemote;
      } // init callback that should return a peer instance like:
      // `({ getPeerId }) => new Peer(getPeerId())`


      providerValue.current.peer = init({
        humanizeError: utils.humanizeError,
        getPeerId: utils.getPeerId,
        isConnectionFromRemote: mode === "master" ? utils.isConnectionFromRemote : undefined
      });
      providerValue.current.promise = (mode === "master" ? core.master : core.remote)["default"](utils).bindConnection(providerValue.current.peer, core.remote ? masterPeerId : undefined); // start resolving the promise as soon as possible (it will be used in `usePeer`)

      providerValue.current.promise.then(function () {});
      return function () {
        if (providerValue.current) {
          // eslint-disable-next-line react-hooks/exhaustive-deps
          providerValue.current.peer.disconnect();
        }
      };
    }, [mode, masterPeerId, init, utils]);
    return /*#__PURE__*/React__default["default"].createElement(MyContext.Provider, {
      value: providerValue.current
    }, children);
  }
  Provider.propTypes = {
    children: PropTypes__default["default"].any,
    sessionStorageKey: PropTypes__default["default"].string,
    humanErrors: PropTypes__default["default"].object,
    mode: PropTypes__default["default"].oneOf(["master", "remote"]),
    masterPeerId: PropTypes__default["default"].string,
    init: PropTypes__default["default"].func
  };

  function _extends() {
    _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];

        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }

      return target;
    };

    return _extends.apply(this, arguments);
  }

  function usePeer() {
    // track if the hook is fully ready
    var _useState = React.useState(false),
        ready = _useState[0],
        setReady = _useState[1]; // track if the peer object is ready (to allow consumer to subscribe to error event)


    var _useState2 = React.useState(false),
        setPeerReady = _useState2[1];

    var context = React.useContext(MyContext);
    var resolvedWrcApi = React.useRef(null);
    React.useEffect(function () {
      // run on next tick (ensure the `then` of the Provider has executed + retrieve the api from the resolve promise)
      Promise.resolve().then(function () {
        var _context$promise;

        setPeerReady(true); // peer object is not null anymore

        context == null ? void 0 : (_context$promise = context.promise) == null ? void 0 : _context$promise.then(function (wrcApi) {
          resolvedWrcApi.current = wrcApi;
          setReady(true);
        });
      }); // eslint-disable-next-line react-hooks/exhaustive-deps
    }, []);
    return _extends({
      ready: ready,
      api: resolvedWrcApi.current
    }, context);
  }

  exports.WebRTCRemoteControlProvider = Provider;
  exports.usePeer = usePeer;

}));
//# sourceMappingURL=react.umd.js.map