@douyinfe/semi-foundation 2.19.0-beta.0 → 2.19.0

package/lib/es/tree/foundation.js

@@ -3,22 +3,11 @@ import _cloneDeep from "lodash/cloneDeep";
 import _pick from "lodash/pick";
 import _difference from "lodash/difference";
 import _isUndefined from "lodash/isUndefined";
-import _Object$assign from "@babel/runtime-corejs3/core-js-stable/object/assign";
-import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
-import _Set from "@babel/runtime-corejs3/core-js-stable/set";
-import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
-import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
-import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
-import _Object$values from "@babel/runtime-corejs3/core-js-stable/object/values";
-import _someInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/some";
-import _everyInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/every";
-import _setTimeout from "@babel/runtime-corejs3/core-js-stable/set-timeout";
-import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
 import BaseFoundation from '../base/foundation';
 import { flattenTreeData, findDescendantKeys, findAncestorKeys, filter, normalizedArr, normalizeKeyList, getMotionKeys, calcCheckedKeysForChecked, calcCheckedKeysForUnchecked, calcCheckedKeys, getValueOrKey, getDragNodesKeys, calcDropRelativePosition, calcDropActualPosition } from './treeUtil';
 export default class TreeFoundation extends BaseFoundation {
   constructor(adapter) {
-    super(_Object$assign({}, adapter));
+    super(Object.assign({}, adapter));
 
     this.clearDragState = () => {
       this._adapter.updateState({
@@ -65,31 +54,27 @@ export default class TreeFoundation extends BaseFoundation {
   }
 
   getCopyFromState(items) {
-    var _context;
-
     const res = {};
-
-    _forEachInstanceProperty(_context = normalizedArr(items)).call(_context, key => {
+    normalizedArr(items).forEach(key => {
       res[key] = _cloneDeep(this.getState(key));
     });
-
     return res;
   }
 
   getTreeNodeProps(key) {
     const {
-      expandedKeys = new _Set([]),
+      expandedKeys = new Set([]),
       selectedKeys = [],
-      checkedKeys = new _Set([]),
-      halfCheckedKeys = new _Set([]),
-      realCheckedKeys = new _Set([]),
+      checkedKeys = new Set([]),
+      halfCheckedKeys = new Set([]),
+      realCheckedKeys = new Set([]),
       keyEntities = {},
-      filteredKeys = new _Set([]),
+      filteredKeys = new Set([]),
       inputValue = '',
-      loadedKeys = new _Set([]),
-      loadingKeys = new _Set([]),
-      filteredExpandedKeys = new _Set([]),
-      disabledKeys = new _Set([])
+      loadedKeys = new Set([]),
+      loadingKeys = new Set([]),
+      filteredExpandedKeys = new Set([]),
+      disabledKeys = new Set([])
     } = this.getStates();
     const {
       treeNodeFilterProp,
@@ -118,7 +103,7 @@ export default class TreeFoundation extends BaseFoundation {
     const treeNodeProps = {
       eventKey: key,
       expanded: isSearching ? filteredExpandedKeys.has(key) : expandedKeys.has(key),
-      selected: _includesInstanceProperty(selectedKeys).call(selectedKeys, key),
+      selected: selectedKeys.includes(key),
       checked: realChecked,
       halfChecked: realHalfChecked,
       pos: String(entity ? entity.pos : ''),
@@ -138,11 +123,8 @@ export default class TreeFoundation extends BaseFoundation {
   }
 
   notifyJsonChange(key, e) {
-    var _context2;
-
     const data = this.getProp('treeDataSimpleJson');
-
-    const selectedPath = _mapInstanceProperty(_context2 = normalizedArr(key)).call(_context2, i => i.replace('-', '.'));
+    const selectedPath = normalizedArr(key).map(i => i.replace('-', '.'));
 
     const value = _pick(data, selectedPath);
 
@@ -167,9 +149,9 @@ export default class TreeFoundation extends BaseFoundation {
     }
 
     if (this.getProp('onChangeWithObject')) {
-      value = _mapInstanceProperty(keyList).call(keyList, itemKey => keyEntities[itemKey].data);
+      value = keyList.map(itemKey => keyEntities[itemKey].data);
     } else {
-      value = getValueOrKey(_mapInstanceProperty(keyList).call(keyList, itemKey => keyEntities[itemKey].data));
+      value = getValueOrKey(keyList.map(itemKey => keyEntities[itemKey].data));
     }
 
     this._adapter.notifyChange(value);
@@ -221,22 +203,18 @@ export default class TreeFoundation extends BaseFoundation {
     let filteredOptsKeys = [];
     let expandedOptsKeys = [];
     let flattenNodes = [];
-    let filteredShownKeys = new _Set([]);
+    let filteredShownKeys = new Set([]);
 
     if (!sugInput) {
       expandedOptsKeys = findAncestorKeys(selectedKeys, keyEntities);
-
-      _forEachInstanceProperty(expandedOptsKeys).call(expandedOptsKeys, item => expandedKeys.add(item));
-
+      expandedOptsKeys.forEach(item => expandedKeys.add(item));
       flattenNodes = flattenTreeData(treeData, expandedKeys);
     } else {
-      var _context3, _context4;
-
-      filteredOptsKeys = _mapInstanceProperty(_context3 = _filterInstanceProperty(_context4 = _Object$values(keyEntities)).call(_context4, item => filter(sugInput, item.data, filterTreeNode, treeNodeFilterProp))).call(_context3, item => item.key);
+      filteredOptsKeys = Object.values(keyEntities).filter(item => filter(sugInput, item.data, filterTreeNode, treeNodeFilterProp)).map(item => item.key);
       expandedOptsKeys = findAncestorKeys(filteredOptsKeys, keyEntities, false);
       const shownChildKeys = findDescendantKeys(filteredOptsKeys, keyEntities, true);
-      filteredShownKeys = new _Set([...shownChildKeys, ...expandedOptsKeys]);
-      flattenNodes = flattenTreeData(treeData, new _Set(expandedOptsKeys), showFilteredOnly && filteredShownKeys);
+      filteredShownKeys = new Set([...shownChildKeys, ...expandedOptsKeys]);
+      flattenNodes = flattenTreeData(treeData, new Set(expandedOptsKeys), showFilteredOnly && filteredShownKeys);
     }
 
     this._adapter.notifySearch(sugInput);
@@ -244,9 +222,9 @@ export default class TreeFoundation extends BaseFoundation {
     this._adapter.updateState({
       expandedKeys,
       flattenNodes,
-      motionKeys: new _Set([]),
-      filteredKeys: new _Set(filteredOptsKeys),
-      filteredExpandedKeys: new _Set(expandedOptsKeys),
+      motionKeys: new Set([]),
+      filteredKeys: new Set(filteredOptsKeys),
+      filteredExpandedKeys: new Set(expandedOptsKeys),
       filteredShownKeys
     });
   }
@@ -290,7 +268,7 @@ export default class TreeFoundation extends BaseFoundation {
       return;
     }
 
-    if (!_includesInstanceProperty(selectedKeys).call(selectedKeys, eventKey)) {
+    if (!selectedKeys.includes(eventKey)) {
       selectedKeys = [eventKey];
       this.notifyChange(eventKey, e);
 
@@ -330,19 +308,15 @@ export default class TreeFoundation extends BaseFoundation {
       disabledKeys
     } = this.getStates();
     const descendantKeys = normalizeKeyList(findDescendantKeys([eventKey], keyEntities, false), keyEntities, true);
-
-    const hasDisabled = _someInstanceProperty(descendantKeys).call(descendantKeys, key => disabledKeys.has(key)); // If the descendant nodes are not disabled, they will be directly changed to checked
-
+    const hasDisabled = descendantKeys.some(key => disabledKeys.has(key)); // If the descendant nodes are not disabled, they will be directly changed to checked
 
     if (!hasDisabled) {
       return targetStatus;
     } // If all descendant nodes that are not disabled are selected, return unchecked, otherwise, return checked
 
 
-    const nonDisabledKeys = _filterInstanceProperty(descendantKeys).call(descendantKeys, key => !disabledKeys.has(key));
-
-    const allChecked = _everyInstanceProperty(nonDisabledKeys).call(nonDisabledKeys, key => checkedKeys.has(key));
-
+    const nonDisabledKeys = descendantKeys.filter(key => !disabledKeys.has(key));
+    const allChecked = nonDisabledKeys.every(key => checkedKeys.has(key));
     return !allChecked;
   }
   /*
@@ -359,16 +333,13 @@ export default class TreeFoundation extends BaseFoundation {
       checkedKeys
     } = this.getCopyFromState(['checkedKeys']);
     const descendantKeys = normalizeKeyList(findDescendantKeys([eventKey], keyEntities, false), keyEntities, true);
-
-    const hasDisabled = _someInstanceProperty(descendantKeys).call(descendantKeys, key => disabledKeys.has(key)); // If none of the descendant nodes are disabled, follow the normal logic
-
+    const hasDisabled = descendantKeys.some(key => disabledKeys.has(key)); // If none of the descendant nodes are disabled, follow the normal logic
 
     if (!hasDisabled) {
       return this.calcCheckedKeys(eventKey, targetStatus);
     }
 
-    const nonDisabled = _filterInstanceProperty(descendantKeys).call(descendantKeys, key => !disabledKeys.has(key));
-
+    const nonDisabled = descendantKeys.filter(key => !disabledKeys.has(key));
     const newCheckedKeys = targetStatus ? [...nonDisabled, ...checkedKeys] : _difference(normalizeKeyList([...checkedKeys], keyEntities, true), nonDisabled);
     return calcCheckedKeys(newCheckedKeys, keyEntities);
   }
@@ -411,7 +382,7 @@ export default class TreeFoundation extends BaseFoundation {
         });
       }
     } else if (checkRelation === 'unRelated') {
-      const newRealCheckedKeys = new _Set(realCheckedKeys);
+      const newRealCheckedKeys = new Set(realCheckedKeys);
       let targetStatus;
 
       if (realCheckedKeys.has(eventKey)) {
@@ -469,7 +440,7 @@ export default class TreeFoundation extends BaseFoundation {
       const newState = {
         [expandedStateKey]: expandedKeys,
         flattenNodes,
-        motionKeys: new _Set(motionKeys),
+        motionKeys: new Set(motionKeys),
         motionType
       };
 
@@ -525,7 +496,7 @@ export default class TreeFoundation extends BaseFoundation {
         loadingKeys: prevLoadingKeys
       } = this.getCopyFromState(['loadedKeys', 'loadingKeys']);
       const newLoadedKeys = prevLoadedKeys.add(key);
-      const newLoadingKeys = new _Set([...prevLoadingKeys]);
+      const newLoadingKeys = new Set([...prevLoadingKeys]);
       newLoadingKeys.delete(key); // onLoad should be triggered before internal setState to avoid `loadData` being triggered twice
 
       onLoad && onLoad(newLoadedKeys, data);
@@ -549,13 +520,13 @@ export default class TreeFoundation extends BaseFoundation {
 
 
   getDragEventNodeData(node) {
-    return _Object$assign(_Object$assign({}, node.data), _pick(node, ['expanded', 'pos', 'children']));
+    return Object.assign(Object.assign({}, node.data), _pick(node, ['expanded', 'pos', 'children']));
   }
 
   triggerDragEvent(name, event, node) {
     let extra = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
     const callEvent = this.getProp(name);
-    callEvent && callEvent(_Object$assign({
+    callEvent && callEvent(Object.assign({
       event,
       node: this.getDragEventNodeData(node)
     }, extra));
@@ -593,7 +564,7 @@ export default class TreeFoundation extends BaseFoundation {
 
     this._adapter.updateState({
       dragging: true,
-      dragNodesKeys: new _Set(getDragNodesKeys(eventKey, keyEntities))
+      dragNodesKeys: new Set(getDragNodesKeys(eventKey, keyEntities))
     });
 
     this.triggerDragEvent('onDragStart', e, treeNode);
@@ -629,9 +600,7 @@ export default class TreeFoundation extends BaseFoundation {
     } // Trigger dragenter after clearing the prev state in dragleave
 
 
-    _setTimeout(() => {
-      var _context5;
-
+    setTimeout(() => {
       this._adapter.updateState({
         dragOverNodeKey: eventKey,
         dropPosition
@@ -648,11 +617,10 @@ export default class TreeFoundation extends BaseFoundation {
         this.delayedDragEnterLogic = {};
       }
 
-      _forEachInstanceProperty(_context5 = _Object$keys(this.delayedDragEnterLogic)).call(_context5, key => {
+      Object.keys(this.delayedDragEnterLogic).forEach(key => {
         clearTimeout(this.delayedDragEnterLogic[key]);
       });
-
-      this.delayedDragEnterLogic[pos] = _setTimeout(() => {
+      this.delayedDragEnterLogic[pos] = window.setTimeout(() => {
         if (!dragging) {
           return;
         }