shineout 1.7.1 → 1.8.0-beta.2

package/es/Transfer/index.js

@@ -1,13 +1,9 @@
-import Transfer from './Transfer'
-import inputable from '../Form/inputable'
-import { compose } from '../utils/func'
-import Datum from '../Datum'
-
-const exportTransfer = compose(
-  inputable,
-  Datum.hoc({ bindProps: ['disabled', 'limit', 'format', 'prediction', 'separator'] })
-)(Transfer)
-
-exportTransfer.displayName = 'ShineoutTransfer'
-
-export default exportTransfer
+import Transfer from './Transfer';
+import inputable from '../Form/inputable';
+import { compose } from '../utils/func';
+import Datum from '../Datum';
+var exportTransfer = compose(inputable, Datum.hoc({
+  bindProps: ['disabled', 'limit', 'format', 'prediction', 'separator']
+}))(Transfer);
+exportTransfer.displayName = 'ShineoutTransfer';
+export default exportTransfer;

package/es/Transfer/item.js

@@ -1,42 +1,65 @@
-import React from 'react'
-import PropTypes from 'prop-types'
-import classnames from 'classnames'
-import Checkbox from '../Checkbox'
-import { PureComponent } from '../component'
-import { transferClass } from './styles'
-import Context from './context'
-
-class Item extends PureComponent {
-  constructor(props) {
-    super(props)
-    this.check = this.check.bind(this)
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import Checkbox from '../Checkbox';
+import { PureComponent } from '../component';
+import { transferClass } from './styles';
+import Context from './context';
+
+var Item =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Item, _PureComponent);
+
+  function Item(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.check = _this.check.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
   }
 
-  check(c) {
-    const { index, selecteds, checkKey, setSelecteds } = this.props
+  var _proto = Item.prototype;
+
+  _proto.check = function check(c) {
+    var _this$props = this.props,
+        index = _this$props.index,
+        selecteds = _this$props.selecteds,
+        checkKey = _this$props.checkKey,
+        setSelecteds = _this$props.setSelecteds;
+
     if (c) {
-      setSelecteds(index, [...selecteds[index], checkKey])
+      setSelecteds(index, [].concat(selecteds[index], [checkKey]));
     } else {
-      setSelecteds(index, selecteds[index].filter(ch => ch !== checkKey))
+      setSelecteds(index, selecteds[index].filter(function (ch) {
+        return ch !== checkKey;
+      }));
     }
-  }
+  };
 
-  render() {
-    const { content, selecteds, checkKey, index, disabled, itemClass } = this.props
-    return (
-      <div className={classnames(transferClass('item', disabled && 'item-disabled'), itemClass)}>
-        <Checkbox
-          className={transferClass('item-check')}
-          onChange={this.check}
-          disabled={disabled}
-          checked={selecteds[index].indexOf(checkKey) > -1}
-        >
-          {content}
-        </Checkbox>
-      </div>
-    )
-  }
-}
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        content = _this$props2.content,
+        selecteds = _this$props2.selecteds,
+        checkKey = _this$props2.checkKey,
+        index = _this$props2.index,
+        disabled = _this$props2.disabled,
+        itemClass = _this$props2.itemClass;
+    return React.createElement("div", {
+      className: classnames(transferClass('item', disabled && 'item-disabled'), itemClass)
+    }, React.createElement(Checkbox, {
+      className: transferClass('item-check'),
+      onChange: this.check,
+      disabled: disabled,
+      checked: selecteds[index].indexOf(checkKey) > -1
+    }, content));
+  };
+
+  return Item;
+}(PureComponent);
 
 Item.propTypes = {
   index: PropTypes.number,
@@ -45,11 +68,13 @@ Item.propTypes = {
   setSelecteds: PropTypes.func,
   content: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
   disabled: PropTypes.oneOfType([PropTypes.bool, PropTypes.func]),
-  itemClass: PropTypes.string,
-}
-
-export default prop => (
-  <Context.Consumer>
-    {value => <Item {...prop} selecteds={value.selecteds} setSelecteds={value.setSelecteds} />}
-  </Context.Consumer>
-)
+  itemClass: PropTypes.string
+};
+export default (function (prop) {
+  return React.createElement(Context.Consumer, null, function (value) {
+    return React.createElement(Item, _extends({}, prop, {
+      selecteds: value.selecteds,
+      setSelecteds: value.setSelecteds
+    }));
+  });
+});

package/es/Transfer/select.js

@@ -1,20 +1,19 @@
-import { getKey } from '../utils/uid'
-
+import { getKey } from '../utils/uid';
 export default function splitSelecteds(selecteds, props) {
-  if (!selecteds) return null
-
-  const { data, keygen, datum } = props
-  const left = []
-  const right = []
-
-  selecteds.forEach(s => {
-    const v = data.find((d, i) => getKey(d, keygen, i) === s)
+  if (!selecteds) return null;
+  var data = props.data,
+      keygen = props.keygen,
+      datum = props.datum;
+  var left = [];
+  var right = [];
+  selecteds.forEach(function (s) {
+    var v = data.find(function (d, i) {
+      return getKey(d, keygen, i) === s;
+    });
 
     if (v) {
-      if (datum.check(v)) right.push(s)
-      else left.push(s)
+      if (datum.check(v)) right.push(s);else left.push(s);
     }
-  })
-
-  return [left, right]
-}
+  });
+  return [left, right];
+}

package/es/Transfer/styles/index.js

@@ -1,4 +1,3 @@
-import transferLess from './transfer.less'
-import genaration from '../../utils/classname'
-
-export const transferClass = genaration(transferLess, 'transfer')
+import transferLess from './transfer.less';
+import genaration from '../../utils/classname';
+export var transferClass = genaration(transferLess, 'transfer');

package/es/Tree/Checkbox.js

@@ -1,62 +1,84 @@
-import React from 'react'
-import PropTypes from 'prop-types'
-import { PureComponent } from '../component'
-import Checkbox from '../Checkbox/Checkbox'
-import { treeClass } from './styles'
-
-export default class extends PureComponent {
-  static propTypes = {
-    datum: PropTypes.object.isRequired,
-    disabled: PropTypes.bool,
-    id: PropTypes.string.isRequired,
-    onChange: PropTypes.func.isRequired,
-  }
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React from 'react';
+import PropTypes from 'prop-types';
+import { PureComponent } from '../component';
+import Checkbox from '../Checkbox/Checkbox';
+import { treeClass } from './styles';
+
+var _default =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(_default, _PureComponent);
 
-  constructor(props) {
-    super(props)
-    this.handleChange = this.handleChange.bind(this)
-    props.datum.bind(props.id, this.forceUpdate.bind(this))
+  function _default(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.handleChange = _this.handleChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    props.datum.bind(props.id, _this.forceUpdate.bind(_assertThisInitialized(_assertThisInitialized(_this))));
+    return _this;
   }
 
-  componentDidMount() {
-    super.componentDidMount()
-    // When dragging a node,
+  var _proto = _default.prototype;
+
+  _proto.componentDidMount = function componentDidMount() {
+    _PureComponent.prototype.componentDidMount.call(this); // When dragging a node,
     // it will first trigger the constructor of the new node,
     // then trigger the willUnmount of the old node,
     // and finally trigger the didMount of the new node,
     // the old node will unload the update event, so bind it here again
-    this.props.datum.bind(this.props.id, this.forceUpdate.bind(this))
-  }
 
-  componentWillUnmount() {
-    super.componentWillUnmount()
-    this.props.datum.unbind(this.props.id)
-  }
 
-  checkDisabled() {
-    const { datum, id, disabled } = this.props
-    if (disabled) return true
+    this.props.datum.bind(this.props.id, this.forceUpdate.bind(this));
+  };
 
-    return datum.isDisabled(id)
-  }
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    _PureComponent.prototype.componentWillUnmount.call(this);
 
-  handleChange(v, checked) {
-    const { datum, id, onChange } = this.props
-    datum.set(id, checked ? 1 : 0)
-    onChange(datum.getValue(), id)
-  }
+    this.props.datum.unbind(this.props.id);
+  };
 
-  render() {
-    const { datum, id } = this.props
-    const checked = datum.getChecked(id)
-
-    return (
-      <Checkbox
-        checked={checked}
-        disabled={this.checkDisabled()}
-        onChange={this.handleChange}
-        className={treeClass('checkbox')}
-      />
-    )
-  }
-}
+  _proto.checkDisabled = function checkDisabled() {
+    var _this$props = this.props,
+        datum = _this$props.datum,
+        id = _this$props.id,
+        disabled = _this$props.disabled;
+    if (disabled) return true;
+    return datum.isDisabled(id);
+  };
+
+  _proto.handleChange = function handleChange(v, checked) {
+    var _this$props2 = this.props,
+        datum = _this$props2.datum,
+        id = _this$props2.id,
+        onChange = _this$props2.onChange;
+    datum.set(id, checked ? 1 : 0);
+    onChange(datum.getValue(), id);
+  };
+
+  _proto.render = function render() {
+    var _this$props3 = this.props,
+        datum = _this$props3.datum,
+        id = _this$props3.id;
+    var checked = datum.getChecked(id);
+    return React.createElement(Checkbox, {
+      checked: checked,
+      disabled: this.checkDisabled(),
+      onChange: this.handleChange,
+      className: treeClass('checkbox')
+    });
+  };
+
+  return _default;
+}(PureComponent);
+
+_defineProperty(_default, "propTypes", {
+  datum: PropTypes.object.isRequired,
+  disabled: PropTypes.bool,
+  id: PropTypes.string.isRequired,
+  onChange: PropTypes.func.isRequired
+});
+
+export { _default as default };

package/es/Tree/Content.js

@@ -1,100 +1,142 @@
-import React from 'react'
-import PropTypes from 'prop-types'
-import classnames from 'classnames'
-import { PureComponent } from '../component'
-import { treeClass } from './styles'
-import Spin from '../Spin'
-import Checkbox from './Checkbox'
-
-const loading = (
-  <span className={treeClass('icon-loading')}>
-    <Spin name="ring" size={12} />
-  </span>
-)
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import { PureComponent } from '../component';
+import { treeClass } from './styles';
+import Spin from '../Spin';
+import Checkbox from './Checkbox';
+var loading = React.createElement("span", {
+  className: treeClass('icon-loading')
+}, React.createElement(Spin, {
+  name: "ring",
+  size: 12
+}));
+
+var Content =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Content, _PureComponent);
+
+  function Content(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.handleNodeClick = _this.handleNodeClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleNodeExpand = _this.handleNodeExpand.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleIndicatorClick = _this.handleIndicatorClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
 
-class Content extends PureComponent {
-  constructor(props) {
-    super(props)
+  var _proto = Content.prototype;
 
-    this.handleNodeClick = this.handleNodeClick.bind(this)
-    this.handleNodeExpand = this.handleNodeExpand.bind(this)
-    this.handleIndicatorClick = this.handleIndicatorClick.bind(this)
-  }
+  _proto.handleNodeClick = function handleNodeClick() {
+    var _this$props = this.props,
+        data = _this$props.data,
+        id = _this$props.id,
+        parentClickExpand = _this$props.parentClickExpand,
+        childrenKey = _this$props.childrenKey;
+    var children = data[childrenKey];
+    var hasChildren = children && children.length > 0;
 
-  handleNodeClick() {
-    const { data, id, parentClickExpand, childrenKey } = this.props
-    const children = data[childrenKey]
-    const hasChildren = children && children.length > 0
     if (hasChildren && parentClickExpand) {
-      this.handleIndicatorClick()
+      this.handleIndicatorClick();
     } else {
-      this.props.onNodeClick(data, id)
+      this.props.onNodeClick(data, id);
     }
-  }
-
-  handleNodeExpand() {
-    const { data, childrenKey, doubleClickExpand } = this.props
-    if (!doubleClickExpand) return
-    const children = data[childrenKey]
-    const hasChildren = children && children.length > 0
-    if (hasChildren) this.handleIndicatorClick()
-  }
-
-  handleIndicatorClick() {
-    const { id, data, onToggle, loader, childrenKey, setFetching } = this.props
-
-    onToggle()
-
-    if (data[childrenKey] !== undefined) return
-
-    setFetching(true)
-    loader(id, data)
-  }
-
-  renderNode() {
-    const { id, active, data, renderItem, expanded } = this.props
-    const render = typeof renderItem === 'function' ? renderItem : d => d[renderItem]
-    return render(data, expanded, active, id)
-  }
-
-  renderIndicator() {
-    const { data, expanded, expandIcons, loader, childrenKey, fetching, iconClass } = this.props
-    const children = data[childrenKey]
-    const icon = expandIcons ? expandIcons[expanded + 0] : <span className={treeClass('default-icon')} />
-    const indicator = (
-      <a
-        onClick={this.handleIndicatorClick}
-        className={classnames(treeClass(`icon-${expanded ? 'sub' : 'plus'}`), iconClass)}
-      >
-        {typeof icon === 'function' ? icon(data) : icon}
-      </a>
-    )
-
-    if (children && children.length > 0) return indicator
-    if (Array.isArray(children) || children === null) return null
-
-    if (fetching && !children) return loading
-    if (loader && !fetching) return indicator
-
-    return null
-  }
-
-  render() {
-    const { data, onToggle, onChange, expanded, draggable, onDragOver, onDrop, ...other } = this.props
-
-    return (
-      <div onDragOver={onDragOver}>
-        {this.renderIndicator()}
-        <div className={treeClass('content')}>
-          {onChange && <Checkbox {...other} onChange={onChange} />}
-          <div className={treeClass('text')} onClick={this.handleNodeClick} onDoubleClick={this.handleNodeExpand}>
-            {this.renderNode()}
-          </div>
-        </div>
-      </div>
-    )
-  }
-}
+  };
+
+  _proto.handleNodeExpand = function handleNodeExpand() {
+    var _this$props2 = this.props,
+        data = _this$props2.data,
+        childrenKey = _this$props2.childrenKey,
+        doubleClickExpand = _this$props2.doubleClickExpand;
+    if (!doubleClickExpand) return;
+    var children = data[childrenKey];
+    var hasChildren = children && children.length > 0;
+    if (hasChildren) this.handleIndicatorClick();
+  };
+
+  _proto.handleIndicatorClick = function handleIndicatorClick() {
+    var _this$props3 = this.props,
+        id = _this$props3.id,
+        data = _this$props3.data,
+        onToggle = _this$props3.onToggle,
+        loader = _this$props3.loader,
+        childrenKey = _this$props3.childrenKey,
+        setFetching = _this$props3.setFetching;
+    onToggle();
+    if (data[childrenKey] !== undefined) return;
+    setFetching(true);
+    loader(id, data);
+  };
+
+  _proto.renderNode = function renderNode() {
+    var _this$props4 = this.props,
+        id = _this$props4.id,
+        active = _this$props4.active,
+        data = _this$props4.data,
+        renderItem = _this$props4.renderItem,
+        expanded = _this$props4.expanded;
+    var render = typeof renderItem === 'function' ? renderItem : function (d) {
+      return d[renderItem];
+    };
+    return render(data, expanded, active, id);
+  };
+
+  _proto.renderIndicator = function renderIndicator() {
+    var _this$props5 = this.props,
+        data = _this$props5.data,
+        expanded = _this$props5.expanded,
+        expandIcons = _this$props5.expandIcons,
+        loader = _this$props5.loader,
+        childrenKey = _this$props5.childrenKey,
+        fetching = _this$props5.fetching,
+        iconClass = _this$props5.iconClass;
+    var children = data[childrenKey];
+    var icon = expandIcons ? expandIcons[expanded + 0] : React.createElement("span", {
+      className: treeClass('default-icon')
+    });
+    var indicator = React.createElement("a", {
+      onClick: this.handleIndicatorClick,
+      className: classnames(treeClass("icon-" + (expanded ? 'sub' : 'plus')), iconClass)
+    }, typeof icon === 'function' ? icon(data) : icon);
+    if (children && children.length > 0) return indicator;
+    if (Array.isArray(children) || children === null) return null;
+    if (fetching && !children) return loading;
+    if (loader && !fetching) return indicator;
+    return null;
+  };
+
+  _proto.render = function render() {
+    var _this$props6 = this.props,
+        data = _this$props6.data,
+        onToggle = _this$props6.onToggle,
+        onChange = _this$props6.onChange,
+        expanded = _this$props6.expanded,
+        draggable = _this$props6.draggable,
+        onDragOver = _this$props6.onDragOver,
+        onDrop = _this$props6.onDrop,
+        other = _objectWithoutPropertiesLoose(_this$props6, ["data", "onToggle", "onChange", "expanded", "draggable", "onDragOver", "onDrop"]);
+
+    return React.createElement("div", {
+      onDragOver: onDragOver
+    }, this.renderIndicator(), React.createElement("div", {
+      className: treeClass('content')
+    }, onChange && React.createElement(Checkbox, _extends({}, other, {
+      onChange: onChange
+    })), React.createElement("div", {
+      className: treeClass('text'),
+      onClick: this.handleNodeClick,
+      onDoubleClick: this.handleNodeExpand
+    }, this.renderNode())));
+  };
+
+  return Content;
+}(PureComponent);
 
 Content.propTypes = {
   active: PropTypes.bool,
@@ -115,7 +157,6 @@ Content.propTypes = {
   setFetching: PropTypes.func,
   fetching: PropTypes.bool,
   doubleClickExpand: PropTypes.bool,
-  iconClass: PropTypes.string,
-}
-
-export default Content
+  iconClass: PropTypes.string
+};
+export default Content;