@quentin-sommer/react-useragent/dist/react-useragent.cjs.development.js

react-useragent React component

'use strict';

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

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var PropTypes = _interopDefault(require('prop-types'));
var React = require('react');
var React__default = _interopDefault(React);
var uaParserJs = require('ua-parser-js');

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 _inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  subClass.__proto__ = superClass;
}

var availableProps = ['computer', 'windows', 'linux', 'mac', 'mobile', 'tablet', 'android', 'ios', 'firefox', 'chrome', 'edge', 'safari'];

var UAContext = /*#__PURE__*/React__default.createContext({
  uaResults: {},
  parser: {}
});

var UAProvider = /*#__PURE__*/function (_React$Component) {
  _inheritsLoose(UAProvider, _React$Component);

  function UAProvider(props) {
    var _this;

    _this = _React$Component.call(this, props) || this;
    var uaParser = new uaParserJs.UAParser();
    var uaResults = {
      android: false,
      ios: false,
      mobile: false,
      tablet: false,
      windows: false,
      mac: false,
      linux: false,
      computer: false,
      firefox: false,
      chrome: false,
      edge: false,
      safari: false
    };
    uaParser.setUA(props.ua);
    uaResults.android = uaParser.getOS().name === 'Android';
    uaResults.ios = uaParser.getOS().name === 'iOS';
    uaResults.mobile = uaParser.getDevice().type === 'mobile';
    uaResults.tablet = uaParser.getDevice().type === 'tablet';
    uaResults.windows = uaParser.getOS().name === 'Windows';
    uaResults.mac = uaParser.getOS().name === 'Mac OS';
    uaResults.linux = uaParser.getOS().name === 'Linux';
    uaResults.computer = uaResults.windows || uaResults.mac || uaResults.linux || uaParser.getDevice().type === undefined;
    uaResults.firefox = uaParser.getBrowser().name === 'Firefox';
    uaResults.chrome = uaParser.getBrowser().name === 'Chrome';
    uaResults.edge = uaParser.getBrowser().name === 'Edge';
    uaResults.safari = uaParser.getBrowser().name === 'Safari';
    _this.uaParser = uaParser;
    _this.uaResults = uaResults;
    return _this;
  }

  var _proto = UAProvider.prototype;

  _proto.render = function render() {
    return React__default.createElement(UAContext.Provider, {
      value: {
        parser: this.uaParser,
        uaResults: this.uaResults
      }
    }, this.props.children); // return React.Children.only(this.props.children)
  };

  return UAProvider;
}(React__default.Component);

UAProvider.propTypes = {
  ua: PropTypes.string.isRequired,
  children: PropTypes.element.isRequired
};

var UserAgent = /*#__PURE__*/function (_React$Component) {
  _inheritsLoose(UserAgent, _React$Component);

  function UserAgent() {
    return _React$Component.apply(this, arguments) || this;
  }

  var _proto = UserAgent.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        children = _this$props.children,
        returnFullParser = _this$props.returnFullParser;
    var ua = this.context;
    var validProps = Object.keys(this.props).filter(function (prop) {
      return availableProps.indexOf(prop) !== -1;
    });
    var ret = validProps.some(function (prop) {
      return ua.uaResults[prop];
    });
    var funcChildren = typeof children === 'function';

    if (validProps.length !== 0) {
      if (funcChildren) {
        return children(ret);
      }

      if (ret) {
        return children;
      }

      return null;
    }

    if (funcChildren) {
      if (returnFullParser) {
        return children(ua.parser);
      }

      return children(ua.uaResults);
    }

    {
      throw new Error('UserAgent should be used with a function as a child when used without any props');
    }
  };

  return UserAgent;
}(React.Component);

UserAgent.contextType = UAContext;
UserAgent.defaultProps = {
  returnFullParser: false
};
UserAgent.propTypes = /*#__PURE__*/_extends({}, /*#__PURE__*/availableProps.reduce(function (acc, cur) {
  var _extends2;

  return _extends({}, acc, (_extends2 = {}, _extends2[cur] = PropTypes.bool, _extends2));
}, {}), {
  returnFullParser: PropTypes.bool
});

exports.UAContext = UAContext;
exports.UserAgent = UserAgent;
exports.UserAgentProvider = UAProvider;
//# sourceMappingURL=react-useragent.cjs.development.js.map