shineout 1.7.1 → 1.8.0-beta.2

package/es/Tree/Root.js

@@ -1,27 +1,31 @@
-import React from 'react'
-import PropTypes from 'prop-types'
-import classnames from 'classnames'
-import { getProps } from '../utils/proptypes'
-import { treeClass } from './styles'
-import List from './List'
-import { isRTL } from '../config'
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import _extends from "@babel/runtime/helpers/extends";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import { getProps } from '../utils/proptypes';
+import { treeClass } from './styles';
+import List from './List';
+import { isRTL } from '../config';
 
 function Root(props) {
-  const className = classnames(treeClass('_', props.line ? 'with-line' : 'no-line', isRTL() && 'rtl'), props.className)
-
-  return <List {...props} className={className} expanded path="" isRoot deepIndex={0} />
+  var className = classnames(treeClass('_', props.line ? 'with-line' : 'no-line', isRTL() && 'rtl'), props.className);
+  return React.createElement(List, _extends({}, props, {
+    className: className,
+    expanded: true,
+    path: "",
+    isRoot: true,
+    deepIndex: 0
+  }));
 }
 
-Root.propTypes = {
-  ...getProps(PropTypes),
+Root.propTypes = _objectSpread({}, getProps(PropTypes), {
   keygen: PropTypes.oneOfType([PropTypes.string, PropTypes.func]).isRequired,
   data: PropTypes.array,
-  line: PropTypes.bool,
-}
-
+  line: PropTypes.bool
+});
 Root.defaultProps = {
   data: [],
-  line: true,
-}
-
-export default Root
+  line: true
+};
+export default Root;

package/es/Tree/Tree.js

@@ -1,251 +1,318 @@
-import React from 'react'
-import PropTypes from 'prop-types'
-import immer from 'immer'
-import { PureComponent } from '../component'
-import { getProps } from '../utils/proptypes'
-import DatumTree from '../Datum/Tree'
-import Root from './Root'
-
-class Tree extends PureComponent {
-  constructor(props) {
-    super(props)
-
-    this.state = { active: null }
-
-    this.nodes = new Map()
-    this.datum =
-      props.datum ||
-      new DatumTree({
-        data: props.data,
-        loader: props.loader,
-        keygen: props.keygen,
-        mode: props.mode,
-        onChange: props.onChange,
-        value: props.value || props.defaultValue,
-        disabled: typeof props.disabled === 'function' ? props.disabled : undefined,
-        childrenKey: props.childrenKey,
-        unmatch: props.unmatch,
-      })
-    this.handleDrop = this.handleDrop.bind(this)
-    this.handleToggle = this.handleToggle.bind(this)
-    this.handleNodeClick = this.handleNodeClick.bind(this)
-    this.bindNode = this.bindNode.bind(this)
-    this.unbindNode = this.unbindNode.bind(this)
-    this.handleDragImageSelector = this.handleProps.bind(this, 'dragImageSelector')
-    this.handleClidrenClass = this.handleProps.bind(this, 'childrenClass')
-    this.handleLeafClass = this.handleProps.bind(this, 'leafClass')
-    this.bindDatum()
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import React from 'react';
+import PropTypes from 'prop-types';
+import immer from 'immer';
+import { PureComponent } from '../component';
+import { getProps } from '../utils/proptypes';
+import DatumTree from '../Datum/Tree';
+import Root from './Root';
+
+var Tree =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Tree, _PureComponent);
+
+  function Tree(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.state = {
+      active: null
+    };
+    _this.nodes = new Map();
+    _this.datum = props.datum || new DatumTree({
+      data: props.data,
+      loader: props.loader,
+      keygen: props.keygen,
+      mode: props.mode,
+      onChange: props.onChange,
+      value: props.value || props.defaultValue,
+      disabled: typeof props.disabled === 'function' ? props.disabled : undefined,
+      childrenKey: props.childrenKey,
+      unmatch: props.unmatch
+    });
+    _this.handleDrop = _this.handleDrop.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleToggle = _this.handleToggle.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleNodeClick = _this.handleNodeClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.bindNode = _this.bindNode.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.unbindNode = _this.unbindNode.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleDragImageSelector = _this.handleProps.bind(_assertThisInitialized(_assertThisInitialized(_this)), 'dragImageSelector');
+    _this.handleClidrenClass = _this.handleProps.bind(_assertThisInitialized(_assertThisInitialized(_this)), 'childrenClass');
+    _this.handleLeafClass = _this.handleProps.bind(_assertThisInitialized(_assertThisInitialized(_this)), 'leafClass');
+
+    _this.bindDatum();
+
+    return _this;
   }
 
-  componentDidUpdate(prevProps) {
+  var _proto = Tree.prototype;
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
     if (prevProps.expanded !== this.props.expanded) {
-      this.handleExpanded(this.props.expanded)
+      this.handleExpanded(this.props.expanded);
     }
+
     if (prevProps.active !== this.props.active) {
-      this.handleActive(this.props.active)
+      this.handleActive(this.props.active);
     }
 
     if (this.props.onChange || this.props.onDrop || this.props.radioUpdate) {
-      this.datum.mode = this.props.mode
-      if (prevProps.value !== this.props.value) this.datum.setValue(this.props.value || [])
-      if (prevProps.data !== this.props.data && this.props.dataUpdate) this.datum.setData(this.props.data)
+      this.datum.mode = this.props.mode;
+      if (prevProps.value !== this.props.value) this.datum.setValue(this.props.value || []);
+      if (prevProps.data !== this.props.data && this.props.dataUpdate) this.datum.setData(this.props.data);
     }
-  }
+  };
 
-  getActive() {
-    const { active } = this.props
-    return active === undefined ? this.state.active : active
-  }
+  _proto.getActive = function getActive() {
+    var active = this.props.active;
+    return active === undefined ? this.state.active : active;
+  };
 
-  bindDatum() {
-    const { bindDatum } = this.props
-    if (bindDatum) bindDatum(this.datum)
-  }
+  _proto.bindDatum = function bindDatum() {
+    var bindDatum = this.props.bindDatum;
+    if (bindDatum) bindDatum(this.datum);
+  };
 
-  bindNode(id, update) {
+  _proto.bindNode = function bindNode(id, update) {
     /*
     if (this.nodes.has(id)) {
       console.error(`Node with '${id}' key has already been added. Tree node's key must be unique.`)
       return {}
     }
     */
-    this.nodes.set(id, update)
+    this.nodes.set(id, update);
+    var active = this.props.active === id;
+    var expanded = this.props.expanded || this.props.defaultExpanded;
 
-    const active = this.props.active === id
-    const expanded = this.props.expanded || this.props.defaultExpanded
     if (this.props.defaultExpandAll) {
-      return { active, expanded: true }
+      return {
+        active: active,
+        expanded: true
+      };
     }
 
-    return { active, expanded: expanded && expanded.indexOf(id) >= 0 }
-  }
+    return {
+      active: active,
+      expanded: expanded && expanded.indexOf(id) >= 0
+    };
+  };
 
-  unbindNode(id) {
-    this.nodes.delete(id)
-  }
+  _proto.unbindNode = function unbindNode(id) {
+    this.nodes.delete(id);
+  };
+
+  _proto.handleExpanded = function handleExpanded(expanded) {
+    var temp = new Set(expanded);
+
+    for (var _iterator = this.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
 
-  handleExpanded(expanded) {
-    const temp = new Set(expanded)
-    for (const [id, update] of this.nodes) {
-      update('expanded', temp.has(id))
+      var _ref2 = _ref,
+          id = _ref2[0],
+          update = _ref2[1];
+      update('expanded', temp.has(id));
     }
-  }
+  };
+
+  _proto.handleActive = function handleActive(active) {
+    for (var _iterator2 = this.nodes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref3 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref3 = _i2.value;
+      }
 
-  handleActive(active) {
-    for (const [id, update] of this.nodes) {
-      update('active', id === active)
+      var _ref4 = _ref3,
+          id = _ref4[0],
+          update = _ref4[1];
+      update('active', id === active);
     }
-  }
+  };
+
+  _proto.handleNodeClick = function handleNodeClick(node, id) {
+    var _this2 = this;
+
+    var _this$props = this.props,
+        active = _this$props.active,
+        onClick = _this$props.onClick;
 
-  handleNodeClick(node, id) {
-    const { active, onClick } = this.props
     if (active === undefined) {
-      this.setState({ active: id }, () => {
-        this.handleActive(id)
-      })
+      this.setState({
+        active: id
+      }, function () {
+        _this2.handleActive(id);
+      });
     }
+
     if (onClick) {
-      onClick(node, id, this.datum.getPath(id))
+      onClick(node, id, this.datum.getPath(id));
     }
-  }
+  };
 
-  handleToggle(id) {
-    const { expanded, onExpand } = this.props
-    let newExpanded
+  _proto.handleToggle = function handleToggle(id) {
+    var _this$props2 = this.props,
+        expanded = _this$props2.expanded,
+        onExpand = _this$props2.onExpand;
+    var newExpanded;
 
     if (!expanded && onExpand) {
-      onExpand([id])
-      return
+      onExpand([id]);
+      return;
     }
 
     if (expanded.indexOf(id) >= 0) {
-      newExpanded = expanded.filter(e => e !== id)
+      newExpanded = expanded.filter(function (e) {
+        return e !== id;
+      });
     } else {
-      newExpanded = [...expanded, id]
+      newExpanded = [].concat(expanded, [id]);
     }
-    if (onExpand) onExpand(newExpanded)
-  }
 
-  handleDrop(id, targetId, position) {
-    const { childrenKey } = this.props
-    const current = this.datum.getPath(id)
-    const target = this.datum.getPath(targetId)
-    const data = immer(this.props.data, draft => {
-      let node = draft
-      let temp
-      let removeNode
-      let offset = 0
-      current.indexPath.forEach((p, i) => {
+    if (onExpand) onExpand(newExpanded);
+  };
+
+  _proto.handleDrop = function handleDrop(id, targetId, position) {
+    var _this3 = this;
+
+    var childrenKey = this.props.childrenKey;
+    var current = this.datum.getPath(id);
+    var target = this.datum.getPath(targetId);
+    var data = immer(this.props.data, function (draft) {
+      var node = draft;
+      var temp;
+      var removeNode;
+      var offset = 0;
+      current.indexPath.forEach(function (p, i) {
         if (i < current.indexPath.length - 1) {
-          node = node[p][childrenKey]
+          node = node[p][childrenKey];
         } else {
-          temp = node
-          removeNode = () => temp.splice(p, 1)[0]
-          node = node[p]
-        }
-      })
+          temp = node;
 
-      let tnode = draft
-      target.indexPath.forEach((p, i) => {
+          removeNode = function removeNode() {
+            return temp.splice(p, 1)[0];
+          };
+
+          node = node[p];
+        }
+      });
+      var tnode = draft;
+      target.indexPath.forEach(function (p, i) {
         if (i < target.indexPath.length - 1) {
-          tnode = tnode[p][childrenKey]
+          tnode = tnode[p][childrenKey];
         } else if (tnode === temp) {
           // same parent
-          removeNode()
+          removeNode();
+
           if (current.index <= target.index) {
-            offset = -1
+            offset = -1;
           }
-          removeNode = () => {}
+
+          removeNode = function removeNode() {};
         }
-      })
+      });
 
       if (position === -1) {
-        tnode = tnode[target.index + offset]
-        if (!Array.isArray(tnode[childrenKey])) tnode[childrenKey] = []
-        tnode[childrenKey].push(node)
-        position = tnode[childrenKey].length - 1
-        const update = this.nodes.get(targetId)
-        if (update) update('expanded', true)
+        tnode = tnode[target.index + offset];
+        if (!Array.isArray(tnode[childrenKey])) tnode[childrenKey] = [];
+        tnode[childrenKey].push(node);
+        position = tnode[childrenKey].length - 1;
+
+        var update = _this3.nodes.get(targetId);
+
+        if (update) update('expanded', true);
       } else {
-        tnode.splice(position + offset, 0, node)
-        targetId = target.path[target.path.length - 1]
+        tnode.splice(position + offset, 0, node);
+        targetId = target.path[target.path.length - 1];
       }
 
-      removeNode()
-    })
-    this.props.onDrop(data, id, targetId, position)
-  }
+      removeNode();
+    });
+    this.props.onDrop(data, id, targetId, position);
+  };
 
-  handleProps(key) {
-    return this.props[key]
-  }
+  _proto.handleProps = function handleProps(key) {
+    return this.props[key];
+  };
 
-  render() {
-    const {
-      className,
-      style,
-      data,
-      disabled,
-      line,
-      keygen,
-      onExpand,
-      onChange,
-      renderItem,
-      mode,
-      onDrop,
-      loader,
-      parentClickExpand,
-      childrenKey,
-      expandIcons,
-      dragImageStyle,
-      dragImageSelector,
-      childrenClass,
-      leafClass,
-      dragHoverExpand,
-      doubleClickExpand,
-      iconClass,
-      nodeClass,
-      dragSibling,
-    } = this.props
-    const onToggle = onExpand ? this.handleToggle : undefined
-
-    return (
-      <Root
-        className={className}
-        data={data}
-        datum={this.datum}
-        disabled={typeof disabled !== 'function' && disabled}
-        bindNode={this.bindNode}
-        keygen={keygen}
-        line={line}
-        loader={loader}
-        mode={mode}
-        unbindNode={this.unbindNode}
-        onChange={onChange}
-        onDrop={onDrop && this.handleDrop}
-        onToggle={onToggle}
-        onNodeClick={this.handleNodeClick}
-        renderItem={renderItem}
-        style={style}
-        parentClickExpand={parentClickExpand}
-        childrenKey={childrenKey}
-        expandIcons={expandIcons}
-        dragImageStyle={dragImageStyle}
-        dragImageSelector={typeof dragImageSelector === 'function' ? dragImageSelector : this.handleDragImageSelector}
-        childrenClass={typeof childrenClass === 'function' ? childrenClass : this.handleClidrenClass}
-        leafClass={typeof leafClass === 'function' ? leafClass : this.handleLeafClass}
-        dragHoverExpand={dragHoverExpand}
-        doubleClickExpand={doubleClickExpand}
-        iconClass={iconClass}
-        nodeClass={nodeClass}
-        dragSibling={dragSibling}
-      />
-    )
-  }
-}
+  _proto.render = function render() {
+    var _this$props3 = this.props,
+        className = _this$props3.className,
+        style = _this$props3.style,
+        data = _this$props3.data,
+        disabled = _this$props3.disabled,
+        line = _this$props3.line,
+        keygen = _this$props3.keygen,
+        onExpand = _this$props3.onExpand,
+        onChange = _this$props3.onChange,
+        renderItem = _this$props3.renderItem,
+        mode = _this$props3.mode,
+        onDrop = _this$props3.onDrop,
+        loader = _this$props3.loader,
+        parentClickExpand = _this$props3.parentClickExpand,
+        childrenKey = _this$props3.childrenKey,
+        expandIcons = _this$props3.expandIcons,
+        dragImageStyle = _this$props3.dragImageStyle,
+        dragImageSelector = _this$props3.dragImageSelector,
+        childrenClass = _this$props3.childrenClass,
+        leafClass = _this$props3.leafClass,
+        dragHoverExpand = _this$props3.dragHoverExpand,
+        doubleClickExpand = _this$props3.doubleClickExpand,
+        iconClass = _this$props3.iconClass,
+        nodeClass = _this$props3.nodeClass,
+        dragSibling = _this$props3.dragSibling;
+    var onToggle = onExpand ? this.handleToggle : undefined;
+    return React.createElement(Root, {
+      className: className,
+      data: data,
+      datum: this.datum,
+      disabled: typeof disabled !== 'function' && disabled,
+      bindNode: this.bindNode,
+      keygen: keygen,
+      line: line,
+      loader: loader,
+      mode: mode,
+      unbindNode: this.unbindNode,
+      onChange: onChange,
+      onDrop: onDrop && this.handleDrop,
+      onToggle: onToggle,
+      onNodeClick: this.handleNodeClick,
+      renderItem: renderItem,
+      style: style,
+      parentClickExpand: parentClickExpand,
+      childrenKey: childrenKey,
+      expandIcons: expandIcons,
+      dragImageStyle: dragImageStyle,
+      dragImageSelector: typeof dragImageSelector === 'function' ? dragImageSelector : this.handleDragImageSelector,
+      childrenClass: typeof childrenClass === 'function' ? childrenClass : this.handleClidrenClass,
+      leafClass: typeof leafClass === 'function' ? leafClass : this.handleLeafClass,
+      dragHoverExpand: dragHoverExpand,
+      doubleClickExpand: doubleClickExpand,
+      iconClass: iconClass,
+      nodeClass: nodeClass,
+      dragSibling: dragSibling
+    });
+  };
+
+  return Tree;
+}(PureComponent);
 
-Tree.propTypes = {
-  ...getProps(PropTypes),
+Tree.propTypes = _objectSpread({}, getProps(PropTypes), {
   active: PropTypes.any,
   data: PropTypes.array,
   defaultExpanded: PropTypes.arrayOf(PropTypes.string),
@@ -271,9 +338,8 @@ Tree.propTypes = {
   doubleClickExpand: PropTypes.bool,
   dragSibling: PropTypes.bool,
   nodeClass: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-  unmatch: PropTypes.bool,
-}
-
+  unmatch: PropTypes.bool
+});
 Tree.defaultProps = {
   data: [],
   defaultExpanded: [],
@@ -281,7 +347,6 @@ Tree.defaultProps = {
   mode: 0,
   dataUpdate: true,
   childrenKey: 'children',
-  dragImageStyle: {},
-}
-
-export default Tree
+  dragImageStyle: {}
+};
+export default Tree;

package/es/Tree/index.js

@@ -1,9 +1,6 @@
-import Tree from './Tree'
-import inputable from '../Form/inputable'
-
-Tree.Select = inputable(Tree)
-Tree.Field = Tree.Select
-
-Tree.displayName = 'ShineoutTree'
-
-export default Tree
+import Tree from './Tree';
+import inputable from '../Form/inputable';
+Tree.Select = inputable(Tree);
+Tree.Field = Tree.Select;
+Tree.displayName = 'ShineoutTree';
+export default Tree;

package/es/Tree/styles/index.js

@@ -1,4 +1,3 @@
-import treeLess from './tree.less'
-import genaration from '../../utils/classname'
-
-export const treeClass = genaration(treeLess, 'tree')
+import treeLess from './tree.less';
+import genaration from '../../utils/classname';
+export var treeClass = genaration(treeLess, 'tree');