@medely/react-fontawesome 0.0.1 → 0.1.0

package/index.es.js

@@ -1,151 +1,181 @@
-import { parse, icon } from '../fontawesome-svg-core';
+import { parse, icon } from '@fortawesome/fontawesome-svg-core';
 import PropTypes from 'prop-types';
 import React from 'react';
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-
-  return keys;
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
 }
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
   }
-
-  return target;
 }
-
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  }, _typeof(obj);
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 obj;
+  return t;
 }
-
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
+function _objectSpread2(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 target;
+  return e;
 }
-
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-
-  var key, i;
-
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
   if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-
-    for (i = 0; i < sourceSymbolKeys.length; i++) {
-      key = sourceSymbolKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-      target[key] = source[key];
-    }
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
   }
-
-  return target;
+  return i;
 }
-
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
 }
-
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 }
-
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
 }
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
 }
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _typeof(o) {
+  "@babel/helpers - typeof";
 
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-  return arr2;
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
 }
 
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+var ICON_PACKS_STARTING_VERSION = '7.0.0';
+
+// Try to get version from installed package first, fallback to env var, then default
+var SVG_CORE_VERSION;
+try {
+  var svgCorePackageJson = require('@fortawesome/fontawesome-svg-core/package.json');
+  SVG_CORE_VERSION = svgCorePackageJson.version;
+} catch (e) {
+  // If package.json can't be loaded, try environment variable
+  SVG_CORE_VERSION = typeof process !== 'undefined' && process.env.FA_VERSION || '7.0.0';
 }
 
 // Get CSS class list from a props object
 function classList(props) {
-  var _classes;
-
   var beat = props.beat,
-      fade = props.fade,
-      beatFade = props.beatFade,
-      bounce = props.bounce,
-      shake = props.shake,
-      flash = props.flash,
-      spin = props.spin,
-      spinPulse = props.spinPulse,
-      spinReverse = props.spinReverse,
-      pulse = props.pulse,
-      fixedWidth = props.fixedWidth,
-      inverse = props.inverse,
-      border = props.border,
-      listItem = props.listItem,
-      flip = props.flip,
-      size = props.size,
-      rotation = props.rotation,
-      pull = props.pull; // map of CSS class names to properties
-
-  var classes = (_classes = {
+    fade = props.fade,
+    beatFade = props.beatFade,
+    bounce = props.bounce,
+    shake = props.shake,
+    flash = props.flash,
+    spin = props.spin,
+    spinPulse = props.spinPulse,
+    spinReverse = props.spinReverse,
+    pulse = props.pulse,
+    fixedWidth = props.fixedWidth,
+    inverse = props.inverse,
+    border = props.border,
+    listItem = props.listItem,
+    flip = props.flip,
+    size = props.size,
+    rotation = props.rotation,
+    pull = props.pull,
+    swapOpacity = props.swapOpacity,
+    rotateBy = props.rotateBy,
+    widthAuto = props.widthAuto;
+
+  // Check if we're using version 7 or later
+  var isVersion7OrLater = versionCheckGte(SVG_CORE_VERSION, ICON_PACKS_STARTING_VERSION);
+
+  // map of CSS class names to properties
+  var classes = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
     'fa-beat': beat,
     'fa-fade': fade,
     'fa-beat-fade': beatFade,
@@ -163,9 +193,10 @@ function classList(props) {
     'fa-flip': flip === true,
     'fa-flip-horizontal': flip === 'horizontal' || flip === 'both',
     'fa-flip-vertical': flip === 'vertical' || flip === 'both'
-  }, _defineProperty(_classes, "fa-".concat(size), typeof size !== 'undefined' && size !== null), _defineProperty(_classes, "fa-rotate-".concat(rotation), typeof rotation !== 'undefined' && rotation !== null && rotation !== 0), _defineProperty(_classes, "fa-pull-".concat(pull), typeof pull !== 'undefined' && pull !== null), _defineProperty(_classes, 'fa-swap-opacity', props.swapOpacity), _classes); // map over all the keys in the classes object
-  // return an array of the keys where the value for the key is not null
+  }, "fa-".concat(size), typeof size !== 'undefined' && size !== null), "fa-rotate-".concat(rotation), typeof rotation !== 'undefined' && rotation !== null && rotation !== 0), "fa-pull-".concat(pull), typeof pull !== 'undefined' && pull !== null), 'fa-swap-opacity', swapOpacity), 'fa-rotate-by', isVersion7OrLater && rotateBy), 'fa-width-auto', isVersion7OrLater && widthAuto);
 
+  // map over all the keys in the classes object
+  // return an array of the keys where the value for the key is not null
   return Object.keys(classes).map(function (key) {
     return classes[key] ? key : null;
   }).filter(function (key) {
@@ -173,35 +204,82 @@ function classList(props) {
   });
 }
 
+// check if verion1 is greater than or equal to version2
+function versionCheckGte(version1, version2) {
+  var _version1$split = version1.split('-'),
+    _version1$split2 = _slicedToArray(_version1$split, 2),
+    v1Base = _version1$split2[0],
+    v1PreRelease = _version1$split2[1];
+  var _version2$split = version2.split('-'),
+    _version2$split2 = _slicedToArray(_version2$split, 2),
+    v2Base = _version2$split2[0],
+    v2PreRelease = _version2$split2[1];
+  var v1Parts = v1Base.split('.');
+  var v2Parts = v2Base.split('.');
+
+  // Compare version numbers first
+  for (var i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
+    var v1Part = v1Parts[i] || '0';
+    var v2Part = v2Parts[i] || '0';
+
+    // Compare numeric values
+    var v1Num = parseInt(v1Part, 10);
+    var v2Num = parseInt(v2Part, 10);
+    if (v1Num !== v2Num) {
+      return v1Num > v2Num;
+    }
+  }
+
+  // If numeric values are equal, look for any remaining parts
+  // that would make one version greater than the other
+  for (var _i = 0; _i < Math.max(v1Parts.length, v2Parts.length); _i++) {
+    var _v1Part = v1Parts[_i] || '0';
+    var _v2Part = v2Parts[_i] || '0';
+    if (_v1Part !== _v2Part) {
+      // When numeric values are equal but strings differ,
+      // the one without leading zeros is greater
+      if (_v1Part.length !== _v2Part.length) {
+        return _v1Part.length < _v2Part.length;
+      }
+    }
+  }
+
+  // If version numbers are equal, compare pre-release identifiers
+  // A version with a pre-release identifier is less than one without
+  if (v1PreRelease && !v2PreRelease) return false;
+  if (!v1PreRelease && v2PreRelease) return true;
+  return true;
+}
+
 // Camelize taken from humps
 // humps is copyright © 2012+ Dom Christie
 // Released under the MIT license.
+
 // Performant way to determine if object coerces to a number
 function _isNumerical(obj) {
-  obj = obj - 0; // eslint-disable-next-line no-self-compare
+  obj = obj - 0;
 
+  // eslint-disable-next-line no-self-compare
   return obj === obj;
 }
-
 function camelize(string) {
   if (_isNumerical(string)) {
     return string;
-  } // eslint-disable-next-line no-useless-escape
-
+  }
 
+  // eslint-disable-next-line no-useless-escape
   string = string.replace(/[\-_\s]+(.)?/g, function (match, chr) {
     return chr ? chr.toUpperCase() : '';
-  }); // Ensure 1st char is always lowercase
+  });
 
+  // Ensure 1st char is always lowercase
   return string.substr(0, 1).toLowerCase() + string.substr(1);
 }
 
-var _excluded$1 = ["style"];
-
+var _excluded = ["style"];
 function capitalize(val) {
   return val.charAt(0).toUpperCase() + val.slice(1);
 }
-
 function styleToObject(style) {
   return style.split(';').map(function (s) {
     return s.trim();
@@ -215,50 +293,40 @@ function styleToObject(style) {
     return acc;
   }, {});
 }
-
 function convert(createElement, element) {
   var extraProps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
   if (typeof element === 'string') {
     return element;
   }
-
   var children = (element.children || []).map(function (child) {
     return convert(createElement, child);
   });
-  /* eslint-disable dot-notation */
 
+  /* eslint-disable dot-notation */
   var mixins = Object.keys(element.attributes || {}).reduce(function (acc, key) {
     var val = element.attributes[key];
-
     switch (key) {
       case 'class':
         acc.attrs['className'] = val;
         delete element.attributes['class'];
         break;
-
       case 'style':
         acc.attrs['style'] = styleToObject(val);
         break;
-
       default:
         if (key.indexOf('aria-') === 0 || key.indexOf('data-') === 0) {
           acc.attrs[key.toLowerCase()] = val;
         } else {
           acc.attrs[camelize(key)] = val;
         }
-
     }
-
     return acc;
   }, {
     attrs: {}
   });
-
   var _extraProps$style = extraProps.style,
-      existingStyle = _extraProps$style === void 0 ? {} : _extraProps$style,
-      remaining = _objectWithoutProperties(extraProps, _excluded$1);
-
+    existingStyle = _extraProps$style === void 0 ? {} : _extraProps$style,
+    remaining = _objectWithoutProperties(extraProps, _excluded);
   mixins.attrs['style'] = _objectSpread2(_objectSpread2({}, mixins.attrs['style']), existingStyle);
   /* eslint-enable */
 
@@ -266,50 +334,47 @@ function convert(createElement, element) {
 }
 
 var PRODUCTION = false;
-
 try {
   PRODUCTION = process.env.NODE_ENV === 'production';
 } catch (e) {}
-
 function log () {
   if (!PRODUCTION && console && typeof console.error === 'function') {
     var _console;
-
     (_console = console).error.apply(_console, arguments);
   }
 }
 
+// Normalize icon arguments
 function normalizeIconArgs(icon) {
   // this has everything that it needs to be rendered which means it was probably imported
   // directly from an icon svg package
   if (icon && _typeof(icon) === 'object' && icon.prefix && icon.iconName && icon.icon) {
     return icon;
   }
-
   if (parse.icon) {
     return parse.icon(icon);
-  } // if the icon is null, there's nothing to do
-
+  }
 
+  // if the icon is null, there's nothing to do
   if (icon === null) {
     return null;
-  } // if the icon is an object and has a prefix and an icon name, return it
-
+  }
 
+  // if the icon is an object and has a prefix and an icon name, return it
   if (icon && _typeof(icon) === 'object' && icon.prefix && icon.iconName) {
     return icon;
-  } // if it's an array with length of two
-
+  }
 
+  // if it's an array with length of two
   if (Array.isArray(icon) && icon.length === 2) {
     // use the first item as prefix, second as icon name
     return {
       prefix: icon[0],
       iconName: icon[1]
     };
-  } // if it's a string, use it as the icon name
-
+  }
 
+  // if it's a string, use it as the icon name
   if (typeof icon === 'string') {
     return {
       prefix: 'fas',
@@ -329,21 +394,49 @@ function objectWithKey(key, value) {
   return Array.isArray(value) && value.length > 0 || !Array.isArray(value) && value ? _defineProperty({}, key, value) : {};
 }
 
-var _excluded = ["forwardedRef"];
-function FontAwesomeIcon(_ref) {
-  var forwardedRef = _ref.forwardedRef,
-      props = _objectWithoutProperties(_ref, _excluded);
-
-  var iconArgs = props.icon,
-      maskArgs = props.mask,
-      symbol = props.symbol,
-      className = props.className,
-      title = props.title,
-      titleId = props.titleId,
-      maskId = props.maskId;
+var defaultProps = {
+  border: false,
+  className: '',
+  mask: null,
+  maskId: null,
+  // the fixedWidth property has been deprecated as of version 7
+  fixedWidth: false,
+  inverse: false,
+  flip: false,
+  icon: null,
+  listItem: false,
+  pull: null,
+  pulse: false,
+  rotation: null,
+  rotateBy: false,
+  size: null,
+  spin: false,
+  spinPulse: false,
+  spinReverse: false,
+  beat: false,
+  fade: false,
+  beatFade: false,
+  bounce: false,
+  shake: false,
+  symbol: false,
+  title: '',
+  titleId: null,
+  transform: null,
+  swapOpacity: false,
+  widthAuto: false
+};
+var FontAwesomeIcon = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var allProps = _objectSpread2(_objectSpread2({}, defaultProps), props);
+  var iconArgs = allProps.icon,
+    maskArgs = allProps.mask,
+    symbol = allProps.symbol,
+    className = allProps.className,
+    title = allProps.title,
+    titleId = allProps.titleId,
+    maskId = allProps.maskId;
   var iconLookup = normalizeIconArgs(iconArgs);
-  var classes = objectWithKey('classes', [].concat(_toConsumableArray(classList(props)), _toConsumableArray(className.split(' '))));
-  var transform = objectWithKey('transform', typeof props.transform === 'string' ? parse.transform(props.transform) : props.transform);
+  var classes = objectWithKey('classes', [].concat(_toConsumableArray(classList(allProps)), _toConsumableArray((className || '').split(' '))));
+  var transform = objectWithKey('transform', typeof allProps.transform === 'string' ? parse.transform(allProps.transform) : allProps.transform);
   var mask = objectWithKey('mask', normalizeIconArgs(maskArgs));
   var renderedIcon = icon(iconLookup, _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, classes), transform), mask), {}, {
     symbol: symbol,
@@ -351,24 +444,22 @@ function FontAwesomeIcon(_ref) {
     titleId: titleId,
     maskId: maskId
   }));
-
   if (!renderedIcon) {
     log('Could not find icon', iconLookup);
     return null;
   }
-
   var abstract = renderedIcon.abstract;
   var extraProps = {
-    ref: forwardedRef
+    ref: ref
   };
-  Object.keys(props).forEach(function (key) {
+  Object.keys(allProps).forEach(function (key) {
     // eslint-disable-next-line no-prototype-builtins
-    if (!FontAwesomeIcon.defaultProps.hasOwnProperty(key)) {
-      extraProps[key] = props[key];
+    if (!defaultProps.hasOwnProperty(key)) {
+      extraProps[key] = allProps[key];
     }
   });
   return convertCurry(abstract[0], extraProps);
-}
+});
 FontAwesomeIcon.displayName = 'FontAwesomeIcon';
 FontAwesomeIcon.propTypes = {
   beat: PropTypes.bool,
@@ -380,6 +471,7 @@ FontAwesomeIcon.propTypes = {
   flash: PropTypes.bool,
   mask: PropTypes.oneOfType([PropTypes.object, PropTypes.array, PropTypes.string]),
   maskId: PropTypes.string,
+  // the fixedWidth property has been deprecated as of version 7
   fixedWidth: PropTypes.bool,
   inverse: PropTypes.bool,
   flip: PropTypes.oneOf([true, false, 'horizontal', 'vertical', 'both']),
@@ -388,6 +480,7 @@ FontAwesomeIcon.propTypes = {
   pull: PropTypes.oneOf(['right', 'left']),
   pulse: PropTypes.bool,
   rotation: PropTypes.oneOf([0, 90, 180, 270]),
+  rotateBy: PropTypes.bool,
   shake: PropTypes.bool,
   size: PropTypes.oneOf(['2xs', 'xs', 'sm', 'lg', 'xl', '2xl', '1x', '2x', '3x', '4x', '5x', '6x', '7x', '8x', '9x', '10x']),
   spin: PropTypes.bool,
@@ -397,35 +490,8 @@ FontAwesomeIcon.propTypes = {
   title: PropTypes.string,
   titleId: PropTypes.string,
   transform: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
-  swapOpacity: PropTypes.bool
-};
-FontAwesomeIcon.defaultProps = {
-  border: false,
-  className: '',
-  mask: null,
-  maskId: null,
-  fixedWidth: false,
-  inverse: false,
-  flip: false,
-  icon: null,
-  listItem: false,
-  pull: null,
-  pulse: false,
-  rotation: null,
-  size: null,
-  spin: false,
-  spinPulse: false,
-  spinReverse: false,
-  beat: false,
-  fade: false,
-  beatFade: false,
-  bounce: false,
-  shake: false,
-  symbol: false,
-  title: '',
-  titleId: null,
-  transform: null,
-  swapOpacity: false
+  swapOpacity: PropTypes.bool,
+  widthAuto: PropTypes.bool
 };
 var convertCurry = convert.bind(null, React.createElement);