shineout 1.7.0 → 1.7.1-beta.3

package/es/Rate/Rate.js

@@ -1,176 +1,228 @@
-import React from 'react'
-import PropTypes from 'prop-types'
-import classnames from 'classnames'
-import { PureComponent } from '../component'
-import { range } from '../utils/numbers'
-import { getParent } from '../utils/dom/element'
-import { getProps, defaultProps } from '../utils/proptypes'
-import { rateClass } from './styles'
-import getDataset from '../utils/dom/getDataset'
-
-const MIN_SIZE = 12
-class Rate extends PureComponent {
-  constructor(props) {
-    super(props)
-
-    this.state = {
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import { PureComponent } from '../component';
+import { range } from '../utils/numbers';
+import { getParent } from '../utils/dom/element';
+import { getProps, defaultProps } from '../utils/proptypes';
+import { rateClass } from './styles';
+import getDataset from '../utils/dom/getDataset';
+var MIN_SIZE = 12;
+
+var Rate =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Rate, _PureComponent);
+
+  function Rate(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.state = {
       hover: 0,
-      highlight: -1,
-    }
+      highlight: -1
+    };
+    return _this;
   }
 
-  getValue() {
-    const { hover } = this.state
-    return hover === 0 ? this.props.value : hover
-  }
+  var _proto = Rate.prototype;
 
-  getStyle() {
-    const { size } = this.props
-    if (!size) return undefined
-    const parsed = Math.max(MIN_SIZE, parseFloat(size))
-    return { width: parsed, fontSize: parsed, position: 'relative' }
-  }
+  _proto.getValue = function getValue() {
+    var hover = this.state.hover;
+    return hover === 0 ? this.props.value : hover;
+  };
 
-  getScale() {
-    const { size } = this.props
-    if (size >= MIN_SIZE) return undefined
+  _proto.getStyle = function getStyle() {
+    var size = this.props.size;
+    if (!size) return undefined;
+    var parsed = Math.max(MIN_SIZE, parseFloat(size));
     return {
-      transform: `scale(${size / MIN_SIZE})`,
-    }
-  }
-
-  getIcon(icons, i, isBg) {
-    const { repeat, allowHalf } = this.props
-    const value = this.getValue()
-    const remain = value - i
+      width: parsed,
+      fontSize: parsed,
+      position: 'relative'
+    };
+  };
+
+  _proto.getScale = function getScale() {
+    var size = this.props.size;
+    if (size >= MIN_SIZE) return undefined;
+    return {
+      transform: "scale(" + size / MIN_SIZE + ")"
+    };
+  };
+
+  _proto.getIcon = function getIcon(icons, i, isBg) {
+    var _this$props = this.props,
+        repeat = _this$props.repeat,
+        allowHalf = _this$props.allowHalf;
+    var value = this.getValue();
+    var remain = value - i;
+    var icon;
 
-    let icon
     if (!Array.isArray(icons)) {
-      icon = icons
+      icon = icons;
     } else {
-      icon = icons[repeat ? value - 1 : i]
-      if (!icon) icon = icons[icons.length - 1]
+      icon = icons[repeat ? value - 1 : i];
+      if (!icon) icon = icons[icons.length - 1];
     }
 
-    if (remain <= 0 || remain >= 1 || isBg) return icon
-
-    const style = { width: `${remain * 100}%`, display: 'block', overflow: 'hidden', fontSize: 'inherit' }
-    return (
-      <span style={style} className={allowHalf && rateClass('allow-half')}>
-        {icon}
-      </span>
-    )
-  }
-
-  handleClick(...args) {
-    let value = args[0]
-    const e = args[1]
-    const { clearable, allowHalf } = this.props
-    if (allowHalf && getParent(e.target, `.${rateClass('allow-half')}`)) {
-      value -= 0.5
+    if (remain <= 0 || remain >= 1 || isBg) return icon;
+    var style = {
+      width: remain * 100 + "%",
+      display: 'block',
+      overflow: 'hidden',
+      fontSize: 'inherit'
+    };
+    return React.createElement("span", {
+      style: style,
+      className: allowHalf && rateClass('allow-half')
+    }, icon);
+  };
+
+  _proto.handleClick = function handleClick() {
+    var _this2 = this;
+
+    var value = arguments.length <= 0 ? undefined : arguments[0];
+    var e = arguments.length <= 1 ? undefined : arguments[1];
+    var _this$props2 = this.props,
+        clearable = _this$props2.clearable,
+        allowHalf = _this$props2.allowHalf;
+
+    if (allowHalf && getParent(e.target, "." + rateClass('allow-half'))) {
+      value -= 0.5;
     }
+
     if (clearable && this.props.value === value) {
-      value = 0
-      this.setState({ hover: 0 })
+      value = 0;
+      this.setState({
+        hover: 0
+      });
     }
-    this.props.onChange(value)
-    this.setState({ highlight: value })
 
-    if (this.highlightTimer) clearTimeout(this.highlightTimer)
-    this.highlightTimer = setTimeout(() => {
-      this.setState({ highlight: -1 })
-    }, 300)
-  }
-
-  handleHover(hover) {
-    this.setState({ hover })
-  }
-
-  handleMove(hover, e) {
-    const { x, width } = e.target.getBoundingClientRect()
-    this.setState({ hover: hover - (x + width / 2 > e.clientX ? 0.5 : 0) })
-  }
-
-  renderBackground() {
-    const { background, max, disabled } = this.props
-    const style = this.getStyle()
-    const value = this.getValue()
-
-    return (
-      <div className={rateClass('background')}>
-        {range(max).map(v => (
-          <span
-            key={v}
-            // the allowHalf only for the front same as background
-            style={Object.assign({ visibility: !disabled && Math.floor(value) > v ? 'hidden' : 'visible' }, style)}
-          >
-            {this.getIcon(background, v, true)}
-          </span>
-        ))}
-      </div>
-    )
-  }
-
-  renderRate() {
-    const { front, max, text, allowHalf } = this.props
-    const { highlight } = this.state
-    const value = this.getValue()
-    const style = this.getStyle()
-
-    return (
-      <div className={rateClass('front')}>
-        {range(max).map(v => (
-          <span
-            key={v}
-            onClick={this.handleClick.bind(this, v + 1)}
-            onMouseMove={allowHalf ? this.handleMove.bind(this, v + 1) : undefined}
-            onMouseEnter={!allowHalf ? this.handleHover.bind(this, v + 1) : undefined}
-            style={style}
-          >
-            {/* Fix React event onMouseLeave not triggered when moving cursor fast */}
-            <div
-              style={{ position: 'absolute', top: 0, right: 0, left: 0, bottom: 0 }}
-              onMouseLeave={this.handleHover.bind(this, 0)}
-            />
-            {value > v ? this.getIcon(front, v) : <span>&nbsp;</span>}
-            {highlight === v + 1 && <i className={rateClass('highlight')}>{this.getIcon(front, v)}</i>}
-          </span>
-        ))}
-        <span className={rateClass('text')}>{text[Math.ceil(value) - 1]}</span>
-      </div>
-    )
-  }
-
-  renderStatic() {
-    const { front, value, max, text } = this.props
-    const style = this.getStyle()
-
-    return (
-      <div className={rateClass('static')}>
-        {range(max).map(v => (
-          <span key={v} style={style}>
-            {value > v && this.getIcon(front, v)}
-          </span>
-        ))}
-        <span className={rateClass('text')}>{text[Math.ceil(value) - 1]}</span>
-      </div>
-    )
-  }
-
-  render() {
-    const className = classnames(rateClass('_'), this.props.className)
-    const ms = Object.assign({}, this.props.style, this.getScale())
-    return (
-      <div className={className} style={ms} {...getDataset(this.props)}>
-        {this.renderBackground()}
-        {this.props.disabled ? this.renderStatic() : this.renderRate()}
-      </div>
-    )
-  }
-}
-
-Rate.propTypes = {
-  ...getProps(PropTypes, 'disabled', 'type'),
+    this.props.onChange(value);
+    this.setState({
+      highlight: value
+    });
+    if (this.highlightTimer) clearTimeout(this.highlightTimer);
+    this.highlightTimer = setTimeout(function () {
+      _this2.setState({
+        highlight: -1
+      });
+    }, 300);
+  };
+
+  _proto.handleHover = function handleHover(hover) {
+    this.setState({
+      hover: hover
+    });
+  };
+
+  _proto.handleMove = function handleMove(hover, e) {
+    var _e$target$getBounding = e.target.getBoundingClientRect(),
+        x = _e$target$getBounding.x,
+        width = _e$target$getBounding.width;
+
+    this.setState({
+      hover: hover - (x + width / 2 > e.clientX ? 0.5 : 0)
+    });
+  };
+
+  _proto.renderBackground = function renderBackground() {
+    var _this3 = this;
+
+    var _this$props3 = this.props,
+        background = _this$props3.background,
+        max = _this$props3.max,
+        disabled = _this$props3.disabled;
+    var style = this.getStyle();
+    var value = this.getValue();
+    return React.createElement("div", {
+      className: rateClass('background')
+    }, range(max).map(function (v) {
+      return React.createElement("span", {
+        key: v // the allowHalf only for the front same as background
+        ,
+        style: Object.assign({
+          visibility: !disabled && Math.floor(value) > v ? 'hidden' : 'visible'
+        }, style)
+      }, _this3.getIcon(background, v, true));
+    }));
+  };
+
+  _proto.renderRate = function renderRate() {
+    var _this4 = this;
+
+    var _this$props4 = this.props,
+        front = _this$props4.front,
+        max = _this$props4.max,
+        text = _this$props4.text,
+        allowHalf = _this$props4.allowHalf;
+    var highlight = this.state.highlight;
+    var value = this.getValue();
+    var style = this.getStyle();
+    return React.createElement("div", {
+      className: rateClass('front')
+    }, range(max).map(function (v) {
+      return React.createElement("span", {
+        key: v,
+        onClick: _this4.handleClick.bind(_this4, v + 1),
+        onMouseMove: allowHalf ? _this4.handleMove.bind(_this4, v + 1) : undefined,
+        onMouseEnter: !allowHalf ? _this4.handleHover.bind(_this4, v + 1) : undefined,
+        style: style
+      }, React.createElement("div", {
+        style: {
+          position: 'absolute',
+          top: 0,
+          right: 0,
+          left: 0,
+          bottom: 0
+        },
+        onMouseLeave: _this4.handleHover.bind(_this4, 0)
+      }), value > v ? _this4.getIcon(front, v) : React.createElement("span", null, "\xA0"), highlight === v + 1 && React.createElement("i", {
+        className: rateClass('highlight')
+      }, _this4.getIcon(front, v)));
+    }), React.createElement("span", {
+      className: rateClass('text')
+    }, text[Math.ceil(value) - 1]));
+  };
+
+  _proto.renderStatic = function renderStatic() {
+    var _this5 = this;
+
+    var _this$props5 = this.props,
+        front = _this$props5.front,
+        value = _this$props5.value,
+        max = _this$props5.max,
+        text = _this$props5.text;
+    var style = this.getStyle();
+    return React.createElement("div", {
+      className: rateClass('static')
+    }, range(max).map(function (v) {
+      return React.createElement("span", {
+        key: v,
+        style: style
+      }, value > v && _this5.getIcon(front, v));
+    }), React.createElement("span", {
+      className: rateClass('text')
+    }, text[Math.ceil(value) - 1]));
+  };
+
+  _proto.render = function render() {
+    var className = classnames(rateClass('_'), this.props.className);
+    var ms = Object.assign({}, this.props.style, this.getScale());
+    return React.createElement("div", _extends({
+      className: className,
+      style: ms
+    }, getDataset(this.props)), this.renderBackground(), this.props.disabled ? this.renderStatic() : this.renderRate());
+  };
+
+  return Rate;
+}(PureComponent);
+
+Rate.propTypes = _objectSpread({}, getProps(PropTypes, 'disabled', 'type'), {
   background: PropTypes.oneOfType([PropTypes.element, PropTypes.array]),
   clearable: PropTypes.bool,
   repeat: PropTypes.bool,
@@ -179,16 +231,13 @@ Rate.propTypes = {
   onChange: PropTypes.func.isRequired,
   size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
   text: PropTypes.array,
-  value: PropTypes.number,
-}
-
-Rate.defaultProps = {
-  ...defaultProps,
+  value: PropTypes.number
+});
+Rate.defaultProps = _objectSpread({}, defaultProps, {
   repeat: true,
   max: 5,
   size: 20,
   text: [],
-  value: 0,
-}
-
-export default Rate
+  value: 0
+});
+export default Rate;

package/es/Rate/index.js

@@ -1,11 +1,18 @@
-import React from 'react'
-import Component from './Rate'
-import inputable from '../Form/inputable'
+import _extends from "@babel/runtime/helpers/extends";
+import React from 'react';
+import Component from './Rate';
+import inputable from '../Form/inputable';
+export default (function (background, front, opts) {
+  if (opts === void 0) {
+    opts = {};
+  }
 
-export default (background, front, opts = {}) => {
-  const Rate = inputable(props => (
-    <Component {...opts} {...props} background={background} front={front || background} />
-  ))
-  Rate.displayName = 'ShineoutRate'
-  return Rate
-}
+  var Rate = inputable(function (props) {
+    return React.createElement(Component, _extends({}, opts, props, {
+      background: background,
+      front: front || background
+    }));
+  });
+  Rate.displayName = 'ShineoutRate';
+  return Rate;
+});

package/es/Rate/styles/index.js

@@ -1,4 +1,3 @@
-import rateLess from './rate.less'
-import genaration from '../../utils/classname'
-
-export const rateClass = genaration(rateLess, 'rate')
+import rateLess from './rate.less';
+import genaration from '../../utils/classname';
+export var rateClass = genaration(rateLess, 'rate');

package/es/Rule/convert.js

@@ -1,74 +1,65 @@
-import { isObject } from '../utils/is'
-import { curry } from '../utils/func'
-
-const quoteReg = /("(?:[^"\\]|\\.)*")|('(?:[^'\\]|\\.)*')/g
-const emptyFuncReg = /([\w|\d$]+)\s*\(\s*\)/
-const funcReg = /([\w|\d$]+)\s*\((.+)\)/
-const numberReg = /^-?(\d*\.)?\d+(e[-+]?\d+)?$/i
-const strArgReg = /\[(\d+)\]/
+import { isObject } from '../utils/is';
+import { curry } from '../utils/func';
+var quoteReg = /("(?:[^"\\]|\\.)*")|('(?:[^'\\]|\\.)*')/g;
+var emptyFuncReg = /([\w|\d$]+)\s*\(\s*\)/;
+var funcReg = /([\w|\d$]+)\s*\((.+)\)/;
+var numberReg = /^-?(\d*\.)?\d+(e[-+]?\d+)?$/i;
+var strArgReg = /\[(\d+)\]/;
 
 function getSingleRule(str, ss) {
-  const firstQuote = str.indexOf('(')
-  if (firstQuote < 0) return [str.trim()]
-
-  let match = emptyFuncReg.exec(str)
-  if (match) return [match[1]]
-
-  match = funcReg.exec(str)
-  if (!match) throw new Error(`"${str}" is not a valid rule.`)
+  var firstQuote = str.indexOf('(');
+  if (firstQuote < 0) return [str.trim()];
+  var match = emptyFuncReg.exec(str);
+  if (match) return [match[1]];
+  match = funcReg.exec(str);
+  if (!match) throw new Error("\"" + str + "\" is not a valid rule.");
+  var rule = [];
+  rule.push(match[1]);
+  match[2].split(',').forEach(function (arg) {
+    arg = arg.trim();
 
-  const rule = []
-  rule.push(match[1])
-  match[2].split(',').forEach((arg) => {
-    arg = arg.trim()
     if (numberReg.test(arg)) {
-      rule.push(parseFloat(arg))
-      return
+      rule.push(parseFloat(arg));
+      return;
     }
-    const m = strArgReg.exec(arg)
-    if (!m) throw new Error(`Rule argument expect a number or a string. Do you missing the quotes of "${arg}"?`)
-    rule.push(ss[m[1]])
-  })
 
-  return rule
+    var m = strArgReg.exec(arg);
+    if (!m) throw new Error("Rule argument expect a number or a string. Do you missing the quotes of \"" + arg + "\"?");
+    rule.push(ss[m[1]]);
+  });
+  return rule;
 }
 
 export function splitRule(str) {
-  const matchs = str.match(quoteReg) || []
-
-  const arr = []
-  let newString = str
-
-  matchs.forEach((m, i) => {
-    arr.push(m.substring(1, m.length - 1).replace(/\\"/g, '"').replace(/\\'/g, "'"))
-    newString = newString.replace(m, `[${i}]`)
-  })
-
-  const rules = []
-  newString.split(';').forEach((s) => {
-    if (s) rules.push(getSingleRule(s, arr))
-  })
-
-  return rules
+  var matchs = str.match(quoteReg) || [];
+  var arr = [];
+  var newString = str;
+  matchs.forEach(function (m, i) {
+    arr.push(m.substring(1, m.length - 1).replace(/\\"/g, '"').replace(/\\'/g, "'"));
+    newString = newString.replace(m, "[" + i + "]");
+  });
+  var rules = [];
+  newString.split(';').forEach(function (s) {
+    if (s) rules.push(getSingleRule(s, arr));
+  });
+  return rules;
 }
-
-export const convertRule = curry((rule, arr) => {
-  const [method, ...args] = arr
-  if (!rule[method]) throw new Error(`Method "${method}" is not existed.`)
-
-  return rule[method](...args)
-})
-
+export var convertRule = curry(function (rule, arr) {
+  var method = arr[0],
+      args = arr.slice(1);
+  if (!rule[method]) throw new Error("Method \"" + method + "\" is not existed.");
+  return rule[method].apply(rule, args);
+});
 export default function (rule, str) {
   if (!isObject(rule) || !str) {
-    console.error(new Error('Convert arguments expect an Rule object and a string.'))
-    return []
+    console.error(new Error('Convert arguments expect an Rule object and a string.'));
+    return [];
   }
 
   try {
-    const convert = convertRule(rule)
-    return splitRule(str).map(convert)
+    var convert = convertRule(rule);
+    return splitRule(str).map(convert);
   } catch (e) {
-    throw new Error(`Conver string "${str}" to rules failed. ${e.message}`)
+    throw new Error("Conver string \"" + str + "\" to rules failed. " + e.message);
   }
-}
+}