react-facebook-next/lib/Process.js

Facebook components like a Login button, Like, Share, Comments or Embedded Post

import _regeneratorRuntime from 'babel-runtime/regenerator';
import _asyncToGenerator from 'babel-runtime/helpers/asyncToGenerator';
import _classCallCheck from 'babel-runtime/helpers/classCallCheck';
import _possibleConstructorReturn from 'babel-runtime/helpers/possibleConstructorReturn';
import _inherits from 'babel-runtime/helpers/inherits';

var _class, _temp2;

import React, { Component, cloneElement } from 'react';
import PropTypes from 'prop-types';
import InitFacebook from './InitFacebook';

var Process = (_temp2 = _class = function (_Component) {
  _inherits(Process, _Component);

  function Process() {
    var _this2 = this;

    var _temp, _this, _ret;

    _classCallCheck(this, Process);

    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = {
      isWorking: false
    }, _this.handleClick = function () {
      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(evn) {
        var facebook, _this$props, dontWait, onResponse, onError, response, _onError;

        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                evn.preventDefault();
                evn.stopPropagation();

                _this.setState({
                  isWorking: true
                });

                _context.prev = 3;
                facebook = _this.state.facebook;

                if (facebook) {
                  _context.next = 7;
                  break;
                }

                throw new Error('Facebook is not initialized');

              case 7:
                _this$props = _this.props, dontWait = _this$props.dontWait, onResponse = _this$props.onResponse, onError = _this$props.onError;

                if (!dontWait) {
                  _context.next = 12;
                  break;
                }

                _this.process(facebook).then(function (response) {
                  if (onResponse) {
                    onResponse(response);
                  }
                }, function (error) {
                  if (onError) {
                    onError(error);
                  }
                });
                _context.next = 18;
                break;

              case 12:
                _context.next = 14;
                return _this.process(facebook);

              case 14:
                response = _context.sent;

                if (!onResponse) {
                  _context.next = 18;
                  break;
                }

                _context.next = 18;
                return onResponse(response);

              case 18:
                _context.next = 26;
                break;

              case 20:
                _context.prev = 20;
                _context.t0 = _context['catch'](3);
                _onError = _this.props.onError;

                if (!_onError) {
                  _context.next = 26;
                  break;
                }

                _context.next = 26;
                return _onError(_context.t0);

              case 26:

                _this.setState({
                  isWorking: false
                });

              case 27:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, _this2, [[3, 20]]);
      }));

      return function (_x) {
        return _ref.apply(this, arguments);
      };
    }(), _this.handleFacebookReady = function (facebook) {
      _this.setState({ facebook: facebook });

      var onReady = _this.props.onReady;

      if (onReady) {
        onReady(facebook);
      }
    }, _temp), _possibleConstructorReturn(_this, _ret);
  }

  Process.prototype.getElement = function getElement() {
    var _props = this.props,
        children = _props.children,
        render = _props.render,
        CustomComponent = _props.component;
    var _state = this.state,
        facebook = _state.facebook,
        isWorking = _state.isWorking;

    var isLoading = !facebook;
    var isReady = !isLoading && !isWorking;

    if (render) {
      return render({
        isWorking: isWorking,
        isLoading: isLoading,
        isReady: isReady,
        onClick: this.handleClick
      });
    }

    if (CustomComponent) {
      return React.createElement(CustomComponent, {
        onClick: this.handleClick,
        isLoading: isLoading,
        isWorking: isWorking,
        isReady: isReady
      });
    }

    return cloneElement(children, {
      onClick: this.handleClick
    });
  };

  Process.prototype.render = function render() {
    return React.createElement(
      InitFacebook,
      { onReady: this.handleFacebookReady },
      this.getElement()
    );
  };

  return Process;
}(Component), _class.propTypes = {
  children: PropTypes.node,
  render: PropTypes.func,
  component: PropTypes.node,
  onReady: PropTypes.func,
  onError: PropTypes.func,
  onResponse: PropTypes.func,
  dontWait: PropTypes.bool
}, _class.defaultProps = {
  children: undefined,
  render: undefined,
  component: undefined,
  onReady: undefined,
  onError: undefined,
  onResponse: undefined,
  dontWait: undefined
}, _temp2);
export { Process as default };
//# sourceMappingURL=Process.js.map