@dmartss/with-sw/lib/index.js

Custom With Service Worker

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Check if it is production environment
 * @async
 * @function isLocal
 * @param {String} location hostname location
 */

function isLocal() {
  return location.hostname === 'localhost' ? _promise2.default.resolve(true) : _promise2.default.resolve(false);
}

/**
 * Check if service workers are supported in the browser
 * @async
 * @function isSupported
 * @param {Object} navigator browser
 */

function isSupported() {
  if (!('serviceWorker' in navigator)) {
    return _promise2.default.reject(new ReferenceError('ServiceWorkers not supported'));
  }
  return _promise2.default.resolve();
}

/**
 * Register the service worker
 * @async
 * @function register
 * @param {Object} navigator browser
 */

function register() {
  return navigator.serviceWorker.register('/sw.js');
}

/**
 * Render the wrapped page and each time is mounted if it's not running in
 * localhost track a `page view` event.
 * @class
 * @extends Component
 * @param {Object} props The component props
 */

exports.default = function (WrappedComponent) {
  var WithSW = function (_Component) {
    (0, _inherits3.default)(WithSW, _Component);

    function WithSW() {
      (0, _classCallCheck3.default)(this, WithSW);
      return (0, _possibleConstructorReturn3.default)(this, (WithSW.__proto__ || (0, _getPrototypeOf2.default)(WithSW)).apply(this, arguments));
    }

    (0, _createClass3.default)(WithSW, [{
      key: 'componentDidMount',
      value: function () {
        var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
          return _regenerator2.default.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  _context.next = 2;
                  return isLocal();

                case 2:
                  if (!_context.sent) {
                    _context.next = 4;
                    break;
                  }

                  return _context.abrupt('return');

                case 4:
                  _context.next = 6;
                  return isSupported();

                case 6:
                  _context.next = 8;
                  return register();

                case 8:
                case 'end':
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function componentDidMount() {
          return _ref.apply(this, arguments);
        }

        return componentDidMount;
      }()
    }, {
      key: 'render',
      value: function render() {
        return _react2.default.createElement(WrappedComponent, this.props);
      }
    }]);
    return WithSW;
  }(_react.Component);

  if (WrappedComponent.getInitialProps) WithSW.getInitialProps = WrappedComponent.getInitialProps;

  return WithSW;
};