@nutui/nutui-react 0.1.0-beta.1

package/dist/esm/Uploader.js

@@ -0,0 +1,482 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _excluded = ["children", "uploadIcon", "name", "accept", "disabled", "multiple", "url", "headers", "timeout", "method", "xhrState", "withCredentials", "data", "isPreview", "isDeletable", "maximum", "capture", "maximize", "className", "autoUpload", "clearInput", "start", "removeImage", "progress", "success", "update", "failure", "oversize", "beforeUpload", "beforeDelete"];
+
+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 _objectSpread(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)); }); } return target; }
+
+import React__default, { useState, useImperativeHandle } from 'react';
+import Icon from './Icon.js';
+import classNames from 'classnames';
+import { c as cn } from './bem-893ad28d.js';
+import '@bem-react/classname';
+
+var UploadOptions = /*#__PURE__*/_createClass(function UploadOptions() {
+  _classCallCheck(this, UploadOptions);
+
+  _defineProperty(this, "url", '');
+
+  _defineProperty(this, "name", 'file');
+
+  _defineProperty(this, "formData", void 0);
+
+  _defineProperty(this, "method", 'post');
+
+  _defineProperty(this, "xhrState", 200);
+
+  _defineProperty(this, "timeout", 30 * 1000);
+
+  _defineProperty(this, "headers", {});
+
+  _defineProperty(this, "withCredentials", false);
+
+  _defineProperty(this, "onStart", void 0);
+
+  _defineProperty(this, "taroFilePath", void 0);
+
+  _defineProperty(this, "onProgress", void 0);
+
+  _defineProperty(this, "onSuccess", void 0);
+
+  _defineProperty(this, "onFailure", void 0);
+});
+
+var Upload = /*#__PURE__*/function () {
+  function Upload(options) {
+    _classCallCheck(this, Upload);
+
+    _defineProperty(this, "options", void 0);
+
+    this.options = options;
+  }
+
+  _createClass(Upload, [{
+    key: "upload",
+    value: function upload() {
+      var options = this.options;
+      var xhr = new XMLHttpRequest();
+      xhr.timeout = options.timeout;
+
+      if (xhr.upload) {
+        var _options$onStart;
+
+        xhr.upload.addEventListener('progress', function (e) {
+          var _options$onProgress;
+
+          (_options$onProgress = options.onProgress) === null || _options$onProgress === void 0 ? void 0 : _options$onProgress.call(options, e, options);
+        }, false);
+
+        xhr.onreadystatechange = function () {
+          if (xhr.readyState === 4) {
+            if (xhr.status === options.xhrState) {
+              var _options$onSuccess;
+
+              (_options$onSuccess = options.onSuccess) === null || _options$onSuccess === void 0 ? void 0 : _options$onSuccess.call(options, xhr.responseText, options);
+            } else {
+              var _options$onFailure;
+
+              (_options$onFailure = options.onFailure) === null || _options$onFailure === void 0 ? void 0 : _options$onFailure.call(options, xhr.responseText, options);
+            }
+          }
+        };
+
+        xhr.withCredentials = options.withCredentials;
+        xhr.open(options.method, options.url, true); // headers
+
+        for (var _i = 0, _Object$entries = Object.entries(options.headers); _i < _Object$entries.length; _i++) {
+          var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+              key = _Object$entries$_i[0],
+              value = _Object$entries$_i[1];
+
+          xhr.setRequestHeader(key, value);
+        }
+
+        (_options$onStart = options.onStart) === null || _options$onStart === void 0 ? void 0 : _options$onStart.call(options, options);
+        xhr.send(options.formData);
+      } else {
+        console.warn('浏览器不支持 XMLHttpRequest');
+      }
+    }
+  }]);
+
+  return Upload;
+}();
+
+var defaultProps = {
+  url: '',
+  maximum: 1,
+  uploadIcon: 'photograph',
+  name: 'file',
+  accept: '*',
+  disabled: false,
+  autoUpload: true,
+  multiple: false,
+  maximize: Number.MAX_VALUE,
+  data: {},
+  headers: {},
+  method: 'post',
+  xhrState: 200,
+  timeout: 1000 * 30,
+  withCredentials: false,
+  clearInput: false,
+  isPreview: true,
+  isDeletable: true,
+  capture: false,
+  beforeDelete: function beforeDelete(file, files) {
+    return true;
+  }
+};
+
+var FileItem = /*#__PURE__*/_createClass(function FileItem() {
+  _classCallCheck(this, FileItem);
+
+  _defineProperty(this, "status", 'ready');
+
+  _defineProperty(this, "uid", new Date().getTime().toString());
+
+  _defineProperty(this, "name", void 0);
+
+  _defineProperty(this, "url", void 0);
+
+  _defineProperty(this, "type", void 0);
+
+  _defineProperty(this, "formData", new FormData());
+});
+
+var InternalUploader = function InternalUploader(props, ref) {
+  var _defaultProps$props = _objectSpread(_objectSpread({}, defaultProps), props),
+      children = _defaultProps$props.children,
+      uploadIcon = _defaultProps$props.uploadIcon,
+      name = _defaultProps$props.name,
+      accept = _defaultProps$props.accept,
+      disabled = _defaultProps$props.disabled,
+      multiple = _defaultProps$props.multiple,
+      url = _defaultProps$props.url,
+      headers = _defaultProps$props.headers,
+      timeout = _defaultProps$props.timeout,
+      method = _defaultProps$props.method,
+      xhrState = _defaultProps$props.xhrState,
+      withCredentials = _defaultProps$props.withCredentials,
+      data = _defaultProps$props.data,
+      isPreview = _defaultProps$props.isPreview,
+      isDeletable = _defaultProps$props.isDeletable,
+      maximum = _defaultProps$props.maximum,
+      capture = _defaultProps$props.capture,
+      maximize = _defaultProps$props.maximize,
+      className = _defaultProps$props.className,
+      autoUpload = _defaultProps$props.autoUpload,
+      clearInput = _defaultProps$props.clearInput,
+      start = _defaultProps$props.start,
+      removeImage = _defaultProps$props.removeImage,
+      progress = _defaultProps$props.progress,
+      success = _defaultProps$props.success,
+      update = _defaultProps$props.update,
+      failure = _defaultProps$props.failure,
+      oversize = _defaultProps$props.oversize,
+      beforeUpload = _defaultProps$props.beforeUpload,
+      beforeDelete = _defaultProps$props.beforeDelete,
+      restProps = _objectWithoutProperties(_defaultProps$props, _excluded);
+
+  var _useState = useState([]),
+      _useState2 = _slicedToArray(_useState, 2),
+      fileList = _useState2[0],
+      setFileList = _useState2[1];
+
+  var _useState3 = useState([]),
+      _useState4 = _slicedToArray(_useState3, 2),
+      uploadQueue = _useState4[0],
+      setUploadQueue = _useState4[1];
+
+  var b = cn('uploader');
+  var classes = classNames(className, b(''));
+  useImperativeHandle(ref, function () {
+    return {
+      submit: function submit() {
+        Promise.all(uploadQueue).then(function (res) {
+          res.forEach(function (i) {
+            return i.upload();
+          });
+        });
+      }
+    };
+  });
+
+  var clearUploadQueue = function clearUploadQueue() {
+    var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : -1;
+
+    if (index > -1) {
+      uploadQueue.splice(index, 1);
+      setUploadQueue(uploadQueue);
+    } else {
+      setUploadQueue([]);
+    }
+  };
+
+  var clearInputValue = function clearInputValue(el) {
+    el.value = '';
+  };
+
+  var executeUpload = function executeUpload(fileItem, index) {
+    var uploadOption = new UploadOptions();
+    uploadOption.url = url;
+
+    for (var _i2 = 0, _Object$entries2 = Object.entries(data); _i2 < _Object$entries2.length; _i2++) {
+      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          key = _Object$entries2$_i[0],
+          value = _Object$entries2$_i[1];
+
+      fileItem.formData.append(key, value);
+    }
+
+    uploadOption.formData = fileItem.formData;
+    uploadOption.timeout = timeout * 1;
+    uploadOption.method = method;
+    uploadOption.xhrState = xhrState;
+    uploadOption.headers = headers;
+    uploadOption.withCredentials = withCredentials;
+
+    uploadOption.onStart = function (option) {
+      clearUploadQueue(index);
+      setFileList(function (fileList) {
+        fileList.map(function (item) {
+          if (item.uid === fileItem.uid) {
+            item.status = 'ready';
+          }
+        });
+        return _toConsumableArray(fileList);
+      });
+      start && start(option);
+    };
+
+    uploadOption.onProgress = function (e, option) {
+      setFileList(function (fileList) {
+        fileList.map(function (item) {
+          if (item.uid === fileItem.uid) {
+            item.status = 'uploading';
+          }
+        });
+        return _toConsumableArray(fileList);
+      });
+      progress && progress({
+        e: e,
+        option: option
+      });
+    };
+
+    uploadOption.onSuccess = function (responseText, option) {
+      setFileList(function (fileList) {
+        update && update(fileList);
+        fileList.map(function (item) {
+          if (item.uid === fileItem.uid) {
+            item.status = 'success';
+          }
+        });
+        return _toConsumableArray(fileList);
+      });
+      success && success({
+        responseText: responseText,
+        option: option
+      });
+    };
+
+    uploadOption.onFailure = function (responseText, option) {
+      setFileList(function (fileList) {
+        fileList.map(function (item) {
+          if (item.uid === fileItem.uid) {
+            item.status = 'error';
+          }
+        });
+        return _toConsumableArray(fileList);
+      });
+      failure && failure({
+        responseText: responseText,
+        option: option
+      });
+    };
+
+    var task = new Upload(uploadOption);
+
+    if (props.autoUpload) {
+      task.upload();
+    } else {
+      uploadQueue.push(new Promise(function (resolve, reject) {
+        resolve(task);
+      }));
+      setUploadQueue(uploadQueue);
+    }
+  };
+
+  var readFile = function readFile(files) {
+    files.forEach(function (file, index) {
+      var formData = new FormData();
+      formData.append(name, file);
+      var fileItem = new FileItem();
+      fileItem.name = file.name;
+      fileItem.status = 'ready';
+      fileItem.type = file.type;
+      fileItem.formData = formData;
+      fileItem.uid = file.lastModified + fileItem.uid;
+      executeUpload(fileItem, index);
+
+      if (isPreview && file.type.includes('image')) {
+        var reader = new FileReader();
+
+        reader.onload = function (event) {
+          fileItem.url = event.target.result;
+          fileList.push(fileItem);
+          setFileList(_toConsumableArray(fileList));
+        };
+
+        reader.readAsDataURL(file);
+      } else {
+        fileList.push(fileItem);
+        setFileList(_toConsumableArray(fileList));
+      }
+    });
+  };
+
+  var filterFiles = function filterFiles(files) {
+    var maximum = props.maximum * 1;
+    var oversizes = new Array();
+    var filterFile = files.filter(function (file) {
+      if (file.size > maximize) {
+        oversizes.push(file);
+        return false;
+      } else {
+        return true;
+      }
+    });
+
+    if (oversizes.length) {
+      oversize && oversize(files);
+    }
+
+    if (filterFile.length > maximum) {
+      filterFile.splice(maximum, filterFile.length - maximum);
+    }
+
+    if (fileList.length !== 0) {
+      var index = maximum - fileList.length;
+      filterFile.splice(index, filterFile.length - index);
+    }
+
+    return filterFile;
+  };
+
+  var onDelete = function onDelete(file, index) {
+    clearUploadQueue(index);
+
+    if (beforeDelete && beforeDelete(file, fileList)) {
+      fileList.splice(index, 1);
+      removeImage && removeImage(file, fileList);
+      setFileList(_toConsumableArray(fileList));
+    } else {
+      console.log('用户阻止了删除！');
+    }
+  };
+
+  var fileChange = function fileChange(event) {
+    if (disabled) {
+      return;
+    }
+
+    var $el = event.target;
+    var files = $el.files;
+
+    if (beforeUpload) {
+      beforeUpload(new Array().slice.call(files)).then(function (f) {
+        var _files = filterFiles(new Array().slice.call(f));
+
+        readFile(_files);
+      });
+    } else {
+      var _files = filterFiles(new Array().slice.call(files));
+
+      readFile(_files);
+    }
+
+    props.change && props.change({
+      fileList: fileList,
+      event: event
+    });
+
+    if (clearInput) {
+      clearInputValue($el);
+    }
+  };
+
+  return React__default.createElement("div", _objectSpread({
+    className: classes
+  }, restProps), children ? React__default.createElement("div", {
+    className: "nut-uploader__slot"
+  }, React__default.createElement(React__default.Fragment, null, children, maximum > fileList.length && React__default.createElement(React__default.Fragment, null, capture ? React__default.createElement("input", {
+    className: "nut-uploader__input",
+    type: "file",
+    capture: "user",
+    name: name,
+    accept: accept,
+    disabled: disabled,
+    multiple: multiple,
+    onChange: fileChange
+  }) : React__default.createElement("input", {
+    className: "nut-uploader__input",
+    type: "file",
+    name: name,
+    accept: accept,
+    disabled: disabled,
+    multiple: multiple,
+    onChange: fileChange
+  })))) : React__default.createElement(React__default.Fragment, null, fileList.length !== 0 && fileList.map(function (item, index) {
+    console.log('item', item);
+    return React__default.createElement("div", {
+      className: "nut-uploader__preview",
+      key: item.uid
+    }, React__default.createElement("div", {
+      className: "nut-uploader__preview-img"
+    }, isDeletable && React__default.createElement(Icon, {
+      color: "rgba(0,0,0,0.6)",
+      className: "close",
+      name: "circle-close",
+      click: function click() {
+        return onDelete(item, index);
+      }
+    }), item.type.includes('image') && item.url && React__default.createElement("img", {
+      className: "nut-uploader__preview-img__c",
+      src: item.url
+    }), item.status !== 'success' && React__default.createElement("div", {
+      className: "tips"
+    }, item.status)));
+  }), maximum > fileList.length && React__default.createElement("div", {
+    className: "nut-uploader__upload"
+  }, React__default.createElement(Icon, {
+    color: "#808080",
+    name: uploadIcon
+  }), capture ? React__default.createElement("input", {
+    className: "nut-uploader__input",
+    type: "file",
+    capture: "user",
+    name: name,
+    accept: accept,
+    disabled: disabled,
+    multiple: multiple,
+    onChange: fileChange
+  }) : React__default.createElement("input", {
+    className: "nut-uploader__input",
+    type: "file",
+    name: name,
+    accept: accept,
+    disabled: disabled,
+    multiple: multiple,
+    onChange: fileChange
+  }))));
+};
+
+var Uploader = React__default.forwardRef(InternalUploader);
+Uploader.defaultProps = defaultProps;
+Uploader.displayName = 'NutUploader';
+export { Uploader as default };

package/dist/esm/UserContext-68f62e66.js

@@ -0,0 +1,3 @@
+import { createContext } from 'react';
+var DataContext = createContext({});
+export { DataContext as D };

package/dist/esm/bem-893ad28d.js

@@ -0,0 +1,8 @@
+import { withNaming } from '@bem-react/classname';
+var cn = withNaming({
+  n: 'nut-',
+  e: '__',
+  m: '--',
+  v: '-'
+});
+export { cn as c };

package/dist/esm/button-345fb015.js

@@ -0,0 +1,110 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["color", "shape", "plain", "loading", "disabled", "type", "size", "block", "icon", "children", "onClick", "className", "style"];
+
+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 _objectSpread(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)); }); } return target; }
+
+import React__default, { useState, useEffect } from 'react';
+import Icon from './Icon.js';
+var defaultProps = {
+  className: '',
+  color: '',
+  shape: 'round',
+  plain: false,
+  loading: false,
+  disabled: false,
+  type: 'default',
+  size: 'normal',
+  block: false,
+  icon: '',
+  style: {},
+  children: undefined,
+  onClick: function onClick(e) {}
+};
+
+var Button = function Button(props) {
+  var _defaultProps$props = _objectSpread(_objectSpread({}, defaultProps), props),
+      color = _defaultProps$props.color,
+      shape = _defaultProps$props.shape,
+      plain = _defaultProps$props.plain,
+      loading = _defaultProps$props.loading,
+      disabled = _defaultProps$props.disabled,
+      type = _defaultProps$props.type,
+      size = _defaultProps$props.size,
+      block = _defaultProps$props.block,
+      icon = _defaultProps$props.icon,
+      children = _defaultProps$props.children,
+      onClick = _defaultProps$props.onClick,
+      className = _defaultProps$props.className,
+      style = _defaultProps$props.style,
+      rest = _objectWithoutProperties(_defaultProps$props, _excluded);
+
+  var _useState = useState(''),
+      _useState2 = _slicedToArray(_useState, 2),
+      btnName = _useState2[0],
+      setBtnName = _useState2[1];
+
+  var _useState3 = useState({}),
+      _useState4 = _slicedToArray(_useState3, 2),
+      btnStyle = _useState4[0],
+      setBtnStyle = _useState4[1];
+
+  useEffect(function () {
+    setBtnName(classes());
+    setBtnStyle(getStyle());
+  }, [className, color, shape, plain, loading, disabled, style, type, size, block, icon, children, onClick]);
+
+  var classes = function classes() {
+    var prefixCls = 'nut-button';
+    return "".concat(prefixCls, " ").concat(type ? "".concat(prefixCls, "--").concat(type) : '', "\n    ").concat(size ? "".concat(prefixCls, "--").concat(size) : '', "\n    ").concat(shape ? "".concat(prefixCls, "--").concat(shape) : '', "\n    ").concat(plain ? "".concat(prefixCls, "--plain") : '', "\n    ").concat(block ? "".concat(prefixCls, "--block") : '', "\n    ").concat(disabled ? "".concat(prefixCls, "--disabled") : '', "\n    ").concat(loading ? "".concat(prefixCls, "--loading") : '');
+  };
+
+  var handleClick = function handleClick(e) {
+    if (!loading && !disabled && onClick) {
+      onClick(e);
+    }
+  };
+
+  var getStyle = function getStyle() {
+    var style = {};
+
+    if (color) {
+      if (plain) {
+        style.color = color;
+        style.background = '#fff';
+
+        if (!(color !== null && color !== void 0 && color.includes('gradient'))) {
+          style.borderColor = color;
+        }
+      } else {
+        style.color = '#fff';
+        style.background = color;
+      }
+    }
+
+    return style;
+  };
+
+  return React__default.createElement("div", _objectSpread(_objectSpread({
+    className: "".concat(btnName, " ").concat(className),
+    style: _objectSpread(_objectSpread({}, btnStyle), style)
+  }, rest), {}, {
+    onClick: function onClick(e) {
+      return handleClick(e);
+    }
+  }), React__default.createElement("div", {
+    className: "nut-button__warp",
+    style: getStyle()
+  }, loading && React__default.createElement(Icon, {
+    name: "loading"
+  }), !loading && icon ? React__default.createElement(Icon, {
+    name: icon
+  }) : '', children));
+};
+
+Button.defaultProps = defaultProps;
+Button.displayName = 'NutButton';
+export { Button as B };

package/dist/esm/context-aa058329.js

@@ -0,0 +1,6 @@
+import React__default from 'react';
+var radioContext = {
+  onChange: function onChange(val) {}
+};
+var RadioContext = React__default.createContext(radioContext);
+export { RadioContext as R };

package/dist/esm/icon-63c0d58f.js

@@ -0,0 +1,70 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["name", "size", "classPrefix", "color", "tag", "children", "className", "style", "click"];
+
+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 _objectSpread(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)); }); } return target; }
+
+import React__default from 'react';
+import { c as cn } from './bem-893ad28d.js';
+var defaultProps = {
+  name: '',
+  size: '',
+  classPrefix: 'nutui-iconfont',
+  color: '',
+  tag: 'i',
+  click: function click(e) {},
+  className: ''
+};
+
+function pxCheck(value) {
+  return Number.isNaN(Number(value)) ? String(value) : "".concat(value, "px");
+}
+
+var Icon = function Icon(props) {
+  var _defaultProps$props = _objectSpread(_objectSpread({}, defaultProps), props),
+      name = _defaultProps$props.name,
+      size = _defaultProps$props.size,
+      classPrefix = _defaultProps$props.classPrefix,
+      color = _defaultProps$props.color,
+      tag = _defaultProps$props.tag,
+      children = _defaultProps$props.children,
+      className = _defaultProps$props.className,
+      style = _defaultProps$props.style,
+      click = _defaultProps$props.click,
+      rest = _objectWithoutProperties(_defaultProps$props, _excluded);
+
+  var isImage = name ? name.indexOf('/') !== -1 : false;
+  var type = isImage ? 'img' : tag;
+  var b = cn('icon');
+
+  var handleClick = function handleClick(e) {
+    if (props.click) {
+      props.click(e);
+    }
+  };
+
+  var hasSrc = function hasSrc() {
+    if (isImage) return {
+      src: name
+    };
+    return {};
+  };
+
+  return React__default.createElement(type, _objectSpread(_objectSpread({
+    className: isImage ? "".concat(className || '', " ").concat(b('img')) : "".concat(className || '', " ").concat(b(null, [classPrefix]), " nut-icon-").concat(name, " "),
+    style: _objectSpread({
+      color: color,
+      fontSize: pxCheck(size),
+      width: pxCheck(size),
+      height: pxCheck(size)
+    }, style)
+  }, rest), {}, {
+    onClick: handleClick
+  }, hasSrc()), children);
+};
+
+Icon.defaultProps = defaultProps;
+Icon.displayName = 'NutIcon';
+export { Icon as I };