shineout 1.7.1 → 1.8.0-beta.2

package/es/Button/Button.js

@@ -1,76 +1,96 @@
-import React, { PureComponent, isValidElement } from 'react'
-import PropTypes from 'prop-types'
-import classnames from 'classnames'
-import { getProps, defaultProps } from '../utils/proptypes'
-import Spin from '../Spin'
-import { wrapSpan } from '../utils/dom/element'
-import { buttonClass } from './styles'
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import React, { PureComponent, isValidElement } from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import { getProps, defaultProps } from '../utils/proptypes';
+import Spin from '../Spin';
+import { wrapSpan } from '../utils/dom/element';
+import { buttonClass } from './styles';
 
-class Button extends PureComponent {
-  getChildren() {
-    const { children, loading, space } = this.props
-    if (!children) return children
-    const parsed = React.Children.map(wrapSpan(children, space), item => {
-      if (loading && isValidElement(item) && item.type.isShineoutIcon) return null
-      return item
-    }).filter(v => v !== null)
-    return parsed
+var Button =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Button, _PureComponent);
+
+  function Button() {
+    return _PureComponent.apply(this, arguments) || this;
   }
 
-  render() {
-    const {
-      outline: outlineProp,
-      type: typeProp,
-      size,
-      href,
-      htmlType,
-      loading,
-      disabled,
-      onRef,
-      shape,
-      text,
-      space,
-      ...others
-    } = this.props
-    const isSecondary = typeProp === 'secondary' && !outlineProp && !text
-    const type = isSecondary ? 'primary' : typeProp
-    const outline = outlineProp || isSecondary
-    const color = outline || type === 'default' ? undefined : '#fff'
-    const className = classnames(
-      buttonClass('_', shape, type, outline && 'outline', {
-        large: size === 'large',
-        small: size === 'small',
-        text: text && 'text',
-        disabled,
-      }),
-      this.props.className
-    )
+  var _proto = Button.prototype;
+
+  _proto.getChildren = function getChildren() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        loading = _this$props.loading,
+        space = _this$props.space;
+    if (!children) return children;
+    var parsed = React.Children.map(wrapSpan(children, space), function (item) {
+      if (loading && isValidElement(item) && item.type.isShineoutIcon) return null;
+      return item;
+    }).filter(function (v) {
+      return v !== null;
+    });
+    return parsed;
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        outlineProp = _this$props2.outline,
+        typeProp = _this$props2.type,
+        size = _this$props2.size,
+        href = _this$props2.href,
+        htmlType = _this$props2.htmlType,
+        loading = _this$props2.loading,
+        disabled = _this$props2.disabled,
+        onRef = _this$props2.onRef,
+        shape = _this$props2.shape,
+        text = _this$props2.text,
+        space = _this$props2.space,
+        others = _objectWithoutPropertiesLoose(_this$props2, ["outline", "type", "size", "href", "htmlType", "loading", "disabled", "onRef", "shape", "text", "space"]);
+
+    var isSecondary = typeProp === 'secondary' && !outlineProp && !text;
+    var type = isSecondary ? 'primary' : typeProp;
+    var outline = outlineProp || isSecondary;
+    var color = outline || type === 'default' ? undefined : '#fff';
+    var className = classnames(buttonClass('_', shape, type, outline && 'outline', {
+      large: size === 'large',
+      small: size === 'small',
+      text: text && 'text',
+      disabled: disabled
+    }), this.props.className);
 
     if (href) {
-      return (
-        <a href={href} {...others} className={className}>
-          {this.props.children}
-        </a>
-      )
+      return React.createElement("a", _extends({
+        href: href
+      }, others, {
+        className: className
+      }), this.props.children);
     }
 
-    const children = this.getChildren()
-    return (
-      // eslint-disable-next-line
-      <button {...others} ref={onRef} disabled={disabled || loading} type={htmlType} className={className}>
-        {loading && (
-          <span className={buttonClass('spin')}>
-            <Spin size={12} name="ring" color={color} />
-          </span>
-        )}
-        {children}
-      </button>
-    )
-  }
-}
+    var children = this.getChildren();
+    return (// eslint-disable-next-line
+      React.createElement("button", _extends({}, others, {
+        ref: onRef,
+        disabled: disabled || loading,
+        type: htmlType,
+        className: className
+      }), loading && React.createElement("span", {
+        className: buttonClass('spin')
+      }, React.createElement(Spin, {
+        size: 12,
+        name: "ring",
+        color: color
+      })), children)
+    );
+  };
+
+  return Button;
+}(PureComponent);
 
-Button.propTypes = {
-  ...getProps(PropTypes, 'disabled', 'size', 'type'),
+Button.propTypes = _objectSpread({}, getProps(PropTypes, 'disabled', 'size', 'type'), {
   children: PropTypes.any,
   href: PropTypes.string,
   htmlType: PropTypes.string,
@@ -79,14 +99,11 @@ Button.propTypes = {
   shape: PropTypes.oneOf(['round', 'circle']),
   outline: PropTypes.bool,
   text: PropTypes.bool,
-  space: PropTypes.bool,
-}
-
-Button.defaultProps = {
-  ...defaultProps,
+  space: PropTypes.bool
+});
+Button.defaultProps = _objectSpread({}, defaultProps, {
   htmlType: 'button',
   outline: false,
-  type: 'default',
-}
-
-export default Button
+  type: 'default'
+});
+export default Button;

package/es/Button/Group.js

@@ -1,37 +1,51 @@
-import React, { Children, PureComponent, cloneElement } from 'react'
-import PropTypes from 'prop-types'
-import classnames from 'classnames'
-import { getProps } from '../utils/proptypes'
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import React, { Children, PureComponent, cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import { getProps } from '../utils/proptypes';
+import { buttonClass } from './styles';
 
-import { buttonClass } from './styles'
+var ButtonGroup =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(ButtonGroup, _PureComponent);
 
-class ButtonGroup extends PureComponent {
-  render() {
-    const { children, outline, size, type } = this.props
+  function ButtonGroup() {
+    return _PureComponent.apply(this, arguments) || this;
+  }
 
-    const typeSetted = type !== 'default'
-    const className = classnames(buttonClass('group', (outline || !typeSetted) && 'outline'), this.props.className)
+  var _proto = ButtonGroup.prototype;
 
-    return (
-      <div className={className}>
-        {Children.toArray(children).map(child =>
-          cloneElement(child, { size, outline, type: typeSetted ? type : child.props.type })
-        )}
-      </div>
-    )
-  }
-}
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        outline = _this$props.outline,
+        size = _this$props.size,
+        type = _this$props.type;
+    var typeSetted = type !== 'default';
+    var className = classnames(buttonClass('group', (outline || !typeSetted) && 'outline'), this.props.className);
+    return React.createElement("div", {
+      className: className
+    }, Children.toArray(children).map(function (child) {
+      return cloneElement(child, {
+        size: size,
+        outline: outline,
+        type: typeSetted ? type : child.props.type
+      });
+    }));
+  };
+
+  return ButtonGroup;
+}(PureComponent);
 
-ButtonGroup.propTypes = {
-  ...getProps(PropTypes, 'size'),
+ButtonGroup.propTypes = _objectSpread({}, getProps(PropTypes, 'size'), {
   children: PropTypes.any.isRequired,
   outline: PropTypes.bool,
-  type: PropTypes.string,
-}
-
+  type: PropTypes.string
+});
 ButtonGroup.defaultProps = {
   outline: false,
-  type: 'default',
-}
-
-export default ButtonGroup
+  type: 'default'
+};
+export default ButtonGroup;

package/es/Button/Once.js

@@ -1,32 +1,48 @@
-import React, { PureComponent } from 'react'
-import PropTypes from 'prop-types'
-import Button from './Button'
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import Button from './Button';
 
-class OnceButton extends PureComponent {
-  constructor(props) {
-    super(props)
+var OnceButton =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(OnceButton, _PureComponent);
 
-    this.state = {
-      loading: props.loading,
-    }
+  function OnceButton(props) {
+    var _this;
 
-    this.handleClick = this.handleClick.bind(this)
+    _this = _PureComponent.call(this, props) || this;
+    _this.state = {
+      loading: props.loading
+    };
+    _this.handleClick = _this.handleClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
   }
 
-  handleClick(e) {
-    const { onClick } = this.props
-    this.setState({ loading: true })
-    if (onClick) onClick(e)
-  }
+  var _proto = OnceButton.prototype;
 
-  render() {
-    return <Button {...this.props} loading={this.state.loading} onClick={this.handleClick} />
-  }
-}
+  _proto.handleClick = function handleClick(e) {
+    var onClick = this.props.onClick;
+    this.setState({
+      loading: true
+    });
+    if (onClick) onClick(e);
+  };
+
+  _proto.render = function render() {
+    return React.createElement(Button, _extends({}, this.props, {
+      loading: this.state.loading,
+      onClick: this.handleClick
+    }));
+  };
+
+  return OnceButton;
+}(PureComponent);
 
 OnceButton.propTypes = {
   loading: PropTypes.bool,
-  onClick: PropTypes.func,
-}
-
-export default OnceButton
+  onClick: PropTypes.func
+};
+export default OnceButton;

package/es/Button/index.js

@@ -1,10 +1,7 @@
-import Button from './Button'
-import Once from './Once'
-import Group from './Group'
-
-Button.Group = Group
-Button.Once = Once
-
-Button.displayName = 'ShineoutButton'
-
-export default Button
+import Button from './Button';
+import Once from './Once';
+import Group from './Group';
+Button.Group = Group;
+Button.Once = Once;
+Button.displayName = 'ShineoutButton';
+export default Button;

package/es/Button/styles/index.js

@@ -1,4 +1,3 @@
-import buttonLess from './button.less'
-import genaration from '../../utils/classname'
-
-export const buttonClass = genaration(buttonLess, 'button')
+import buttonLess from './button.less';
+import genaration from '../../utils/classname';
+export var buttonClass = genaration(buttonLess, 'button');

package/es/Card/Accordion.js

@@ -1,58 +1,71 @@
-import { Children, cloneElement } from 'react'
-import PropTypes from 'prop-types'
-import classnames from 'classnames'
-import { PureComponent } from '../component'
-import { cardClass } from './styles'
-
-const getChildId = (child, i) => {
-  if (child && child.props && child.props.id !== undefined) return child.props.id
-  return i
-}
-
-class Accordion extends PureComponent {
-  constructor(props) {
-    super(props)
-
-    this.state = {
-      active: props.active || props.defaultActive,
-    }
-  }
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import { Children, cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import { PureComponent } from '../component';
+import { cardClass } from './styles';
 
-  getActive() {
-    if (this.props.active !== undefined) return this.props.active
-    return this.state.active
-  }
+var getChildId = function getChildId(child, i) {
+  if (child && child.props && child.props.id !== undefined) return child.props.id;
+  return i;
+};
+
+var Accordion =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Accordion, _PureComponent);
 
-  handleActive(active) {
-    if (active === this.state.active) active = null
-    this.setState({ active })
-    if (this.props.onChange) this.props.onChange(active)
+  function Accordion(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.state = {
+      active: props.active || props.defaultActive
+    };
+    return _this;
   }
 
-  render() {
-    const active = this.getActive()
-    return Children.toArray(this.props.children).map((child, i) => {
-      const childId = getChildId(child, i)
-      const props = {
+  var _proto = Accordion.prototype;
+
+  _proto.getActive = function getActive() {
+    if (this.props.active !== undefined) return this.props.active;
+    return this.state.active;
+  };
+
+  _proto.handleActive = function handleActive(active) {
+    if (active === this.state.active) active = null;
+    this.setState({
+      active: active
+    });
+    if (this.props.onChange) this.props.onChange(active);
+  };
+
+  _proto.render = function render() {
+    var _this2 = this;
+
+    var active = this.getActive();
+    return Children.toArray(this.props.children).map(function (child, i) {
+      var childId = getChildId(child, i);
+      var props = {
         collapsed: active !== childId,
         collapsible: true,
         className: classnames(typeof child === 'object' && child.className, cardClass('accordion')),
-        onCollapse: this.handleActive.bind(this, childId),
-      }
-      return cloneElement(child, props)
-    })
-  }
-}
+        onCollapse: _this2.handleActive.bind(_this2, childId)
+      };
+      return cloneElement(child, props);
+    });
+  };
+
+  return Accordion;
+}(PureComponent);
 
 Accordion.propTypes = {
   active: PropTypes.any,
   children: PropTypes.oneOfType([PropTypes.element, PropTypes.array]),
   defaultActive: PropTypes.number,
-  onChange: PropTypes.func,
-}
-
+  onChange: PropTypes.func
+};
 Accordion.defaultProps = {
-  defaultActive: 0,
-}
-
-export default Accordion
+  defaultActive: 0
+};
+export default Accordion;

package/es/Card/Body.js

@@ -1,46 +1,59 @@
-import React, { PureComponent } from 'react'
-import PropTypes from 'prop-types'
-import classnames from 'classnames'
-import List from '../AnimationList'
-import { cardClass } from './styles'
-
-const CollapseList = List(['collapse'], 'fast')
-
-class Body extends PureComponent {
-  static propTypes = {
-    children: PropTypes.any,
-    className: PropTypes.string,
-    collapsed: PropTypes.bool,
-    collapsible: PropTypes.bool,
-    style: PropTypes.object,
-    onCollapse: PropTypes.func,
-  }
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import List from '../AnimationList';
+import { cardClass } from './styles';
+var CollapseList = List(['collapse'], 'fast');
+
+var Body =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Body, _PureComponent);
 
-  render() {
-    const {
-      className, collapsed, collapsible, onCollapse, ...other
-    } = this.props
-    const newClassName = classnames(cardClass('body'), className)
-
-    if (!collapsible) return <div {...other} className={newClassName} />
-
-    const onClick = typeof collapsed === 'boolean' ? onCollapse : undefined
-    return (
-      <CollapseList show={!collapsed}>
-        <div {...other} className={newClassName}>
-          {other.children}
-          {collapsible === 'bottom' && (
-            <div className={cardClass('foldup')} onClick={onClick}>
-              <span />
-            </div>
-          )}
-        </div>
-      </CollapseList>
-    )
+  function Body() {
+    return _PureComponent.apply(this, arguments) || this;
   }
-}
 
-Body.propTypes = {
-}
+  var _proto = Body.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        collapsed = _this$props.collapsed,
+        collapsible = _this$props.collapsible,
+        onCollapse = _this$props.onCollapse,
+        other = _objectWithoutPropertiesLoose(_this$props, ["className", "collapsed", "collapsible", "onCollapse"]);
+
+    var newClassName = classnames(cardClass('body'), className);
+    if (!collapsible) return React.createElement("div", _extends({}, other, {
+      className: newClassName
+    }));
+    var onClick = typeof collapsed === 'boolean' ? onCollapse : undefined;
+    return React.createElement(CollapseList, {
+      show: !collapsed
+    }, React.createElement("div", _extends({}, other, {
+      className: newClassName
+    }), other.children, collapsible === 'bottom' && React.createElement("div", {
+      className: cardClass('foldup'),
+      onClick: onClick
+    }, React.createElement("span", null))));
+  };
+
+  return Body;
+}(PureComponent);
+
+_defineProperty(Body, "propTypes", {
+  children: PropTypes.any,
+  className: PropTypes.string,
+  collapsed: PropTypes.bool,
+  collapsible: PropTypes.bool,
+  style: PropTypes.object,
+  onCollapse: PropTypes.func
+});
 
-export default Body
+Body.propTypes = {};
+export default Body;