@douyinfe/semi-foundation 2.1.0 → 2.1.4

package/lib/cjs/cascader/foundation.js

@@ -0,0 +1,1061 @@
+"use strict";
+
+var _filterInstanceProperty2 = require("@babel/runtime-corejs3/core-js-stable/instance/filter");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _assign2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
+
+var _some = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/some"));
+
+var _isArray = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _from = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/from"));
+
+var _set = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/set"));
+
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+
+var _bind = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/bind"));
+
+var _every = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/every"));
+
+var _values = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/values"));
+
+var _sort = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/sort"));
+
+var _parseInt2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/parse-int"));
+
+var _includes2 = _interopRequireDefault(require("lodash/includes"));
+
+var _isNumber2 = _interopRequireDefault(require("lodash/isNumber"));
+
+var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
+
+var _cloneDeep2 = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var _assign3 = _interopRequireDefault(require("lodash/assign"));
+
+var _isUndefined2 = _interopRequireDefault(require("lodash/isUndefined"));
+
+var _difference2 = _interopRequireDefault(require("lodash/difference"));
+
+var _get2 = _interopRequireDefault(require("lodash/get"));
+
+var _isEqual2 = _interopRequireDefault(require("lodash/isEqual"));
+
+var _foundation = _interopRequireDefault(require("../base/foundation"));
+
+var _treeUtil = require("../tree/treeUtil");
+
+var _util = require("./util");
+
+// eslint-disable-next-line max-len
+class CascaderFoundation extends _foundation.default {
+  constructor(adapter) {
+    var _this;
+
+    super((0, _assign2.default)({}, adapter));
+    _this = this;
+
+    this.getMergedMotion = () => {
+      const {
+        motion
+      } = this.getProps();
+      const {
+        isSearching
+      } = this.getStates();
+
+      if (isSearching) {
+        const mergedMotion = typeof motion === 'undefined' || motion ? (0, _assign2.default)((0, _assign2.default)({}, motion), {
+          didLeave: function () {
+            const didLeave = (0, _get2.default)(motion, 'didLeave');
+
+            if (typeof didLeave === 'function') {
+              didLeave(...arguments);
+            }
+
+            _this._adapter.updateStates({
+              isSearching: false
+            });
+          }
+        }) : false;
+        return mergedMotion;
+      }
+
+      return motion;
+    };
+  }
+
+  init() {
+    const isOpen = this.getProp('open') || this.getProp('defaultOpen');
+    this.collectOptions(true);
+
+    if (isOpen && !this._isDisabled()) {
+      this.open();
+    }
+  }
+
+  destroy() {
+    this._adapter.unregisterClickOutsideHandler();
+  }
+
+  _isDisabled() {
+    return this.getProp('disabled');
+  }
+
+  _isFilterable() {
+    return Boolean(this.getProp('filterTreeNode')); // filter can be boolean or function
+  }
+
+  _notifyChange(item) {
+    const {
+      onChangeWithObject,
+      multiple
+    } = this.getProps();
+    const valueProp = onChangeWithObject ? [] : 'value';
+
+    if (multiple) {
+      const valuePath = []; // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore 
+
+      (0, _forEach.default)(item).call(item, checkedKey => {
+        const valuePathItem = this.getItemPropPath(checkedKey, valueProp);
+        valuePath.push(valuePathItem);
+      });
+
+      this._adapter.notifyChange(valuePath);
+    } else {
+      const valuePath = (0, _isUndefined2.default)(item) || !('key' in item) ? [] : this.getItemPropPath(item.key, valueProp);
+
+      this._adapter.notifyChange(valuePath);
+    }
+  }
+
+  _isLeaf(item) {
+    if (this.getProp('loadData')) {
+      return Boolean(item.isLeaf);
+    }
+
+    return !item.children || !item.children.length;
+  }
+
+  _clearInput() {
+    this._adapter.updateInputValue('');
+  } // Scenes that may trigger blur:
+  //  1、clickOutSide
+
+
+  _notifyBlur(e) {
+    this._adapter.notifyBlur(e);
+  } // Scenes that may trigger focus:
+  //  1、click selection
+
+
+  _notifyFocus(e) {
+    this._adapter.notifyFocus(e);
+  }
+
+  _isOptionDisabled(key, keyEntities) {
+    var _context;
+
+    const isDisabled = (0, _some.default)(_context = (0, _treeUtil.findAncestorKeys)([key], keyEntities, true)).call(_context, item => keyEntities[item].data.disabled);
+    return isDisabled;
+  }
+
+  getCopyFromState(items) {
+    var _context2;
+
+    const res = {};
+    (0, _forEach.default)(_context2 = (0, _util.normalizedArr)(items)).call(_context2, key => {
+      res[key] = (0, _cloneDeep2.default)(this.getState(key));
+    });
+    return res;
+  } // prop: is array, return all data
+
+
+  getItemPropPath(selectedKey, prop, keyEntities) {
+    const searchMap = keyEntities || this.getState('keyEntities');
+    const selectedItem = searchMap[selectedKey];
+    let path = [];
+
+    if (!selectedItem) {// do nothing
+    } else if (selectedItem._notExist) {
+      path = selectedItem.path;
+    } else {
+      const keyPath = selectedItem.path;
+      path = (0, _isArray.default)(prop) ? (0, _map.default)(keyPath).call(keyPath, key => searchMap[key].data) : (0, _map.default)(keyPath).call(keyPath, key => searchMap[key].data[prop]);
+    }
+
+    return path;
+  }
+
+  _getCacheValue(keyEntities) {
+    const {
+      selectedKeys
+    } = this.getStates();
+    const selectedKey = (0, _from.default)(selectedKeys)[0];
+    let cacheValue;
+    /* selectedKeys does not match keyEntities */
+
+    if ((0, _isEmpty2.default)(keyEntities[selectedKey])) {
+      if ((0, _includes2.default)(selectedKey, 'not-exist-')) {
+        /* Get the value behind not-exist- */
+        // eslint-disable-next-line prefer-destructuring
+        const targetValue = selectedKey.match(/not-exist-(\S*)/)[1]; // eslint-disable-next-line max-depth
+
+        if ((0, _isEmpty2.default)(keyEntities[targetValue])) {
+          cacheValue = targetValue;
+        } else {
+          /**
+           * 典型的场景是: 假设我们选中了 0-0 这个节点，此时 selectedKeys=Set('0-0')，
+           * 输入框会显示 0-0 的 label。当 treeData 发生更新，假设此时 0-0 在 treeData
+           * 中不存在，则 selectedKeys=Set('not-exist-0-0')，此时输入框显示的是 0-0，
+           * 也就是显示 not-exist- 后的内容。当treeData再次更新，假设此时 0-0 在 treeData
+           * 中存在，则 selectedKeys=Set('0-0')，此时输入框显示 0-0 的 label。 这个地
+           * 方做的操作就是，为了例子中第二次更新后 0-0 label 能够正常显示。
+           */
+
+          /**
+           * The typical scenario is: suppose we select the 0-0 node, at this time
+           *  selectedKeys=Set('0-0'), the input box will display a 0-0 label. When
+           *  treeData is updated, assuming 0-0 does not exist in treeData at this
+           *  time, then selectedKeys=Set('not-exist-0-0'), at this time the input
+           *  box displays 0-0, which means not-exist -After the content. When treeData
+           *  is updated again, assuming that 0-0 exists in treeData at this time,
+           *  then selectedKeys=Set('0-0'), and the input box displays a label of
+           *  0-0 at this time. The operation done here is for the 0-0 label to be
+           *  displayed normally after the second update in the example.
+           */
+          cacheValue = keyEntities[targetValue].valuePath;
+        }
+      } else {
+        cacheValue = selectedKey;
+      }
+      /* selectedKeys match keyEntities */
+
+    } else {
+      /* selectedKeys match keyEntities */
+      cacheValue = keyEntities[selectedKey].valuePath;
+    }
+
+    return cacheValue;
+  }
+
+  collectOptions() {
+    let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    const {
+      treeData,
+      value,
+      defaultValue
+    } = this.getProps();
+    const keyEntities = (0, _util.convertDataToEntities)(treeData);
+
+    this._adapter.rePositionDropdown();
+
+    let cacheValue;
+    /* when mount */
+
+    if (init) {
+      cacheValue = defaultValue;
+    } else if (!(0, _isEmpty2.default)(keyEntities)) {
+      cacheValue = this._getCacheValue(keyEntities);
+    }
+
+    const selectedValue = !this._isControlledComponent() ? cacheValue : value;
+
+    if ((0, _util.isValid)(selectedValue)) {
+      this.updateSelectedKey(selectedValue, keyEntities);
+    } else {
+      this._adapter.updateStates({
+        keyEntities
+      });
+    }
+  } // call when props.value change
+
+
+  handleValueChange(value) {
+    const {
+      keyEntities
+    } = this.getStates();
+    const {
+      multiple
+    } = this.getProps();
+    !multiple && this.updateSelectedKey(value, keyEntities);
+  }
+  /**
+   * When single selection, the clear objects of
+   * selectedKeys, activeKeys, filteredKeys, input, etc.
+   */
+
+
+  _getClearSelectedKey(filterable) {
+    const updateStates = {};
+    const {
+      searchPlaceholder,
+      placeholder,
+      multiple
+    } = this.getProps();
+    updateStates.selectedKeys = new _set.default([]);
+    updateStates.activeKeys = new _set.default([]);
+    updateStates.filteredKeys = new _set.default([]);
+
+    if (filterable && !multiple) {
+      updateStates.inputPlaceHolder = searchPlaceholder || placeholder || '';
+      updateStates.inputValue = '';
+    }
+
+    return updateStates;
+  }
+
+  updateSelectedKey(value, keyEntities) {
+    var _context3, _context4;
+
+    const {
+      changeOnSelect,
+      onChangeWithObject,
+      multiple
+    } = this.getProps();
+    const {
+      activeKeys,
+      loadingKeys,
+      loading,
+      keyEntities: keyEntitieState,
+      selectedKeys: selectedKeysState
+    } = this.getStates();
+
+    const filterable = this._isFilterable();
+
+    const loadingActive = (0, _filter.default)(_context3 = [...activeKeys]).call(_context3, i => loadingKeys.has(i));
+    const valuePath = onChangeWithObject ? (0, _map.default)(_context4 = (0, _util.normalizedArr)(value)).call(_context4, i => i.value) : (0, _util.normalizedArr)(value);
+    const selectedKeys = (0, _util.findKeysForValues)(valuePath, keyEntities);
+    let updateStates = {};
+
+    if (selectedKeys.length) {
+      const selectedKey = selectedKeys[0];
+      const selectedItem = keyEntities[selectedKey];
+      /**
+       * When changeOnSelect is turned on, or the target option is a leaf option,
+       * the option is considered to be selected, even if the option is disabled
+       */
+
+      if (changeOnSelect || this._isLeaf(selectedItem.data)) {
+        updateStates.selectedKeys = new _set.default([selectedKey]);
+
+        if (!loadingActive.length) {
+          updateStates.activeKeys = new _set.default(selectedItem.path);
+        }
+
+        if (filterable && !multiple) {
+          const displayText = this.renderDisplayText(selectedKey, keyEntities);
+          updateStates.inputPlaceHolder = displayText;
+          updateStates.inputValue = displayText;
+        }
+        /**
+         * If selectedKeys does not meet the update conditions,
+         * and state.selectedKeys is the same as selectedKeys
+         * at this time, state.selectedKeys should be cleared.
+         * A typical scenario is:
+         * The originally selected node is the leaf node, but
+         * after props.treeData is dynamically updated, the node
+         * is a non-leaf node. At this point, selectedKeys should
+         * be cleared.
+         */
+
+      } else if ((0, _isEqual2.default)(selectedKeys, (0, _from.default)(selectedKeysState))) {
+        updateStates = this._getClearSelectedKey(filterable);
+      }
+    } else if (value && value.length) {
+      const val = valuePath[valuePath.length - 1];
+      const key = "not-exist-".concat(val);
+      const optionNotExist = {
+        data: {
+          label: val,
+          value: val
+        },
+        key,
+        path: valuePath,
+        _notExist: true
+      };
+      updateStates.selectedKeys = new _set.default([key]);
+
+      if (filterable && !multiple) {
+        const displayText = this._defaultRenderText(valuePath);
+
+        updateStates.inputPlaceHolder = displayText;
+        updateStates.inputValue = displayText;
+      }
+
+      keyEntities[key] = optionNotExist; // Fix: 1155, if the data is loaded asynchronously to update treeData, the emptying operation should not be done when entering the updateSelectedKey method
+    } else if (loading) {
+      // Use assign to avoid overwriting the'not-exist- * 'property of keyEntities after asynchronous loading
+      // Overwriting'not-exist- * 'will cause selectionContent to be emptied unexpectedly when clicking on a dropDown item
+      updateStates.keyEntities = (0, _assign3.default)(keyEntitieState, keyEntities);
+
+      this._adapter.updateStates(updateStates);
+
+      return;
+    } else {
+      updateStates = this._getClearSelectedKey(filterable);
+    }
+
+    updateStates.keyEntities = keyEntities;
+
+    this._adapter.updateStates(updateStates);
+  }
+
+  open() {
+    const filterable = this._isFilterable();
+
+    this._adapter.openMenu();
+
+    if (filterable) {
+      this._clearInput();
+    }
+
+    if (this._isControlledComponent()) {
+      this.reCalcActiveKeys();
+    }
+
+    this._adapter.notifyDropdownVisibleChange(true);
+
+    this._adapter.registerClickOutsideHandler(e => this.close(e));
+  }
+
+  reCalcActiveKeys() {
+    const {
+      selectedKeys,
+      activeKeys,
+      keyEntities
+    } = this.getStates();
+    const selectedKey = [...selectedKeys][0];
+    const selectedItem = keyEntities[selectedKey];
+
+    if (!selectedItem) {
+      return;
+    }
+
+    const newActiveKeys = new _set.default(selectedItem.path);
+
+    if (!(0, _isEqual2.default)(newActiveKeys, activeKeys)) {
+      this._adapter.updateStates({
+        activeKeys: newActiveKeys
+      });
+    }
+  }
+
+  close(e, key) {
+    const {
+      multiple
+    } = this.getProps();
+
+    this._adapter.closeMenu();
+
+    this._adapter.notifyDropdownVisibleChange(false);
+
+    this._adapter.unregisterClickOutsideHandler();
+
+    if (this._isFilterable()) {
+      const {
+        selectedKeys
+      } = this.getStates();
+      let inputValue = '';
+
+      if (key && !multiple) {
+        inputValue = this.renderDisplayText(key);
+      } else if (selectedKeys.size && !multiple) {
+        inputValue = this.renderDisplayText([...selectedKeys][0]);
+      }
+
+      this._adapter.updateStates({
+        inputValue
+      });
+    }
+
+    this._notifyBlur(e);
+  }
+
+  handleItemClick(e, item) {
+    const isDisabled = this._isDisabled();
+
+    if (isDisabled) {
+      return;
+    }
+
+    this.handleSingleSelect(e, item);
+
+    this._adapter.rePositionDropdown();
+  }
+
+  handleItemHover(e, item) {
+    const isDisabled = this._isDisabled();
+
+    if (isDisabled) {
+      return;
+    }
+
+    this.handleShowNextByHover(item);
+  }
+
+  handleShowNextByHover(item) {
+    const {
+      keyEntities
+    } = this.getStates();
+    const {
+      data,
+      key
+    } = item;
+
+    const isLeaf = this._isLeaf(data);
+
+    const activeKeys = keyEntities[key].path;
+
+    this._adapter.updateStates({
+      activeKeys: new _set.default(activeKeys)
+    });
+
+    if (!isLeaf) {
+      this.notifyIfLoadData(item);
+    }
+  }
+
+  onItemCheckboxClick(item) {
+    const isDisabled = this._isDisabled();
+
+    if (isDisabled) {
+      return;
+    }
+
+    this._handleMultipleSelect(item);
+
+    this._adapter.rePositionDropdown();
+  }
+
+  handleClick(e) {
+    const isDisabled = this._isDisabled();
+
+    const isFilterable = this._isFilterable();
+
+    const {
+      isOpen
+    } = this.getStates();
+
+    if (isDisabled) {
+      return;
+    } else if (!isOpen) {
+      this.open();
+
+      this._notifyFocus(e);
+    } else if (isOpen && !isFilterable) {
+      this.close(e);
+    }
+  }
+
+  toggleHoverState(bool) {
+    this._adapter.toggleHovering(bool);
+  }
+
+  _defaultRenderText(path, displayRender) {
+    if (displayRender && typeof displayRender === 'function') {
+      return displayRender(path);
+    } else {
+      return path.join(' / ');
+    }
+  }
+
+  renderDisplayText(targetKey, keyEntities) {
+    const renderFunc = this.getProp('displayRender');
+    const displayProp = this.getProp('displayProp');
+    const displayPath = this.getItemPropPath(targetKey, displayProp, keyEntities);
+    return this._defaultRenderText(displayPath, renderFunc);
+  }
+
+  handleNodeLoad(item) {
+    const {
+      data,
+      key
+    } = item;
+    const {
+      loadedKeys: prevLoadedKeys,
+      loadingKeys: prevLoadingKeys
+    } = this.getCopyFromState(['loadedKeys', 'loadingKeys']);
+    const newLoadedKeys = prevLoadedKeys.add(key);
+    const newLoadingKeys = new _set.default([...prevLoadingKeys]);
+    newLoadingKeys.delete(key); // onLoad should trigger before internal setState to avoid `loadData` trigger twice.
+
+    this._adapter.notifyOnLoad(newLoadedKeys, data);
+
+    this._adapter.updateStates({
+      loadingKeys: newLoadingKeys
+    });
+  }
+
+  notifyIfLoadData(item) {
+    const {
+      data,
+      key
+    } = item;
+
+    this._adapter.updateStates({
+      loading: false
+    });
+
+    if (!data.isLeaf && !data.children && this.getProp('loadData')) {
+      var _context5;
+
+      const {
+        loadedKeys,
+        loadingKeys
+      } = this.getCopyFromState(['loadedKeys', 'loadingKeys']);
+
+      if (loadedKeys.has(key) || loadingKeys.has(key)) {
+        return;
+      }
+
+      this._adapter.updateStates({
+        loading: true
+      });
+
+      const {
+        keyEntities
+      } = this.getStates();
+      const optionPath = this.getItemPropPath(key, [], keyEntities);
+
+      this._adapter.updateStates({
+        loadingKeys: loadingKeys.add(key)
+      });
+
+      this._adapter.notifyLoadData(optionPath, (0, _bind.default)(_context5 = this.handleNodeLoad).call(_context5, this, item));
+    }
+  }
+
+  handleSingleSelect(e, item) {
+    const {
+      changeOnSelect: allowChange,
+      filterLeafOnly,
+      multiple
+    } = this.getProps();
+    const {
+      keyEntities,
+      selectedKeys,
+      isSearching
+    } = this.getStates();
+
+    const filterable = this._isFilterable();
+
+    const {
+      data,
+      key
+    } = item;
+
+    const isLeaf = this._isLeaf(data);
+
+    const activeKeys = keyEntities[key].path;
+    const selectedKey = [key];
+    const hasChanged = key !== [...selectedKeys][0];
+
+    if (!isLeaf && !allowChange && !isSearching) {
+      this._adapter.updateStates({
+        activeKeys: new _set.default(activeKeys)
+      });
+
+      this.notifyIfLoadData(item);
+      return;
+    }
+
+    if (multiple) {
+      this._adapter.updateStates({
+        activeKeys: new _set.default(activeKeys)
+      });
+    } else {
+      this._adapter.notifySelect(data.value);
+
+      if (hasChanged) {
+        this._notifyChange(item);
+
+        this.notifyIfLoadData(item);
+
+        if (this._isControlledComponent()) {
+          this._adapter.updateStates({
+            activeKeys: new _set.default(activeKeys)
+          });
+
+          if (isLeaf) {
+            this.close(e);
+          }
+
+          return;
+        }
+
+        this._adapter.updateStates({
+          activeKeys: new _set.default(activeKeys),
+          selectedKeys: new _set.default(selectedKey)
+        });
+
+        const displayText = this.renderDisplayText(key);
+
+        if (filterable) {
+          this._adapter.updateInputPlaceHolder(displayText);
+        }
+
+        if (isLeaf) {
+          this.close(e, key);
+        } else if (!filterLeafOnly && isSearching) {
+          this.close(e, key);
+        }
+      } else {
+        this.close(e);
+      }
+    }
+  }
+
+  _handleMultipleSelect(item) {
+    const {
+      key
+    } = item;
+    const {
+      checkedKeys,
+      keyEntities,
+      mergedCheckedKeys
+    } = this.getStates();
+    const {
+      autoMergeValue,
+      max,
+      disableStrictly
+    } = this.getProps(); // prev checked status
+
+    const prevCheckedStatus = checkedKeys.has(key); // next checked status
+
+    const curCheckedStatus = disableStrictly ? this.calcChekcedStatus(!prevCheckedStatus, key) : !prevCheckedStatus; // calculate all key of nodes that are checked or half checked
+
+    const {
+      checkedKeys: curCheckedKeys,
+      halfCheckedKeys: curHalfCheckedKeys
+    } = disableStrictly ? this.calcNonDisabedCheckedKeys(key, curCheckedStatus) : this.calcCheckedKeys(key, curCheckedStatus);
+    const curMergedCheckedKeys = new _set.default((0, _treeUtil.normalizeKeyList)(curCheckedKeys, keyEntities));
+    const curRealCheckedKeys = autoMergeValue ? curMergedCheckedKeys : curCheckedKeys;
+
+    if ((0, _isNumber2.default)(max)) {
+      if (autoMergeValue) {
+        // When it exceeds max, the quantity is allowed to be reduced, and no further increase is allowed
+        if (mergedCheckedKeys.size < curMergedCheckedKeys.size && curMergedCheckedKeys.size > max) {
+          const checkedEntities = [];
+          (0, _forEach.default)(curMergedCheckedKeys).call(curMergedCheckedKeys, itemKey => {
+            checkedEntities.push(keyEntities[itemKey]);
+          });
+
+          this._adapter.notifyOnExceed(checkedEntities);
+
+          return;
+        }
+      } else {
+        // When it exceeds max, the quantity is allowed to be reduced, and no further increase is allowed
+        if (checkedKeys.size < curCheckedKeys.size && curCheckedKeys.size > max) {
+          const checkedEntities = [];
+          (0, _forEach.default)(curCheckedKeys).call(curCheckedKeys, itemKey => {
+            checkedEntities.push(keyEntities[itemKey]);
+          });
+
+          this._adapter.notifyOnExceed(checkedEntities);
+
+          return;
+        }
+      }
+    }
+
+    if (!this._isControlledComponent()) {
+      this._adapter.updateStates({
+        checkedKeys: curCheckedKeys,
+        halfCheckedKeys: curHalfCheckedKeys,
+        mergedCheckedKeys: curMergedCheckedKeys
+      });
+    } // The click event during multiple selection will definitely cause the checked state of node to change,
+    // so there is no need to judge the value to change.
+
+
+    this._notifyChange(curRealCheckedKeys);
+
+    if (curCheckedStatus) {
+      this._notifySelect(curRealCheckedKeys);
+    }
+
+    this._adapter.updateStates({
+      inputValue: ''
+    });
+  }
+
+  calcNonDisabedCheckedKeys(eventKey, targetStatus) {
+    const {
+      keyEntities,
+      disabledKeys
+    } = this.getStates();
+    const {
+      checkedKeys
+    } = this.getCopyFromState(['checkedKeys']);
+    const descendantKeys = (0, _treeUtil.normalizeKeyList)((0, _treeUtil.findDescendantKeys)([eventKey], keyEntities, false), keyEntities, true);
+    const hasDisabled = (0, _some.default)(descendantKeys).call(descendantKeys, key => disabledKeys.has(key));
+
+    if (!hasDisabled) {
+      return this.calcCheckedKeys(eventKey, targetStatus);
+    }
+
+    const nonDisabled = (0, _filter.default)(descendantKeys).call(descendantKeys, key => !disabledKeys.has(key));
+    const newCheckedKeys = targetStatus ? [...nonDisabled, ...checkedKeys] : (0, _difference2.default)((0, _treeUtil.normalizeKeyList)([...checkedKeys], keyEntities, true), nonDisabled);
+    return (0, _treeUtil.calcCheckedKeys)(newCheckedKeys, keyEntities);
+  }
+
+  calcChekcedStatus(targetStatus, eventKey) {
+    if (!targetStatus) {
+      return targetStatus;
+    }
+
+    const {
+      checkedKeys,
+      keyEntities,
+      disabledKeys
+    } = this.getStates();
+    const descendantKeys = (0, _treeUtil.normalizeKeyList)((0, _treeUtil.findDescendantKeys)([eventKey], keyEntities, false), keyEntities, true);
+    const hasDisabled = (0, _some.default)(descendantKeys).call(descendantKeys, key => disabledKeys.has(key));
+
+    if (!hasDisabled) {
+      return targetStatus;
+    }
+
+    const nonDisabledKeys = (0, _filter.default)(descendantKeys).call(descendantKeys, key => !disabledKeys.has(key));
+    const allChecked = (0, _every.default)(nonDisabledKeys).call(nonDisabledKeys, key => checkedKeys.has(key));
+    return !allChecked;
+  }
+
+  _notifySelect(keys) {
+    const {
+      keyEntities
+    } = this.getStates();
+    const values = [];
+    (0, _forEach.default)(keys).call(keys, key => {
+      if (!(0, _isEmpty2.default)(keyEntities) && !(0, _isEmpty2.default)(keyEntities[key])) {
+        const valueItem = keyEntities[key].data.value;
+        values.push(valueItem);
+      }
+    });
+    const formatValue = values.length === 1 ? values[0] : values;
+
+    this._adapter.notifySelect(formatValue);
+  }
+  /**
+   * calculate all key of nodes that are checked or half checked
+   * @param {string} key key of node
+   * @param {boolean} curCheckedStatus checked status of node
+   */
+
+
+  calcCheckedKeys(key, curCheckedStatus) {
+    const {
+      keyEntities
+    } = this.getStates();
+    const {
+      checkedKeys,
+      halfCheckedKeys
+    } = this.getCopyFromState(['checkedKeys', 'halfCheckedKeys']);
+    return curCheckedStatus ? (0, _treeUtil.calcCheckedKeysForChecked)(key, keyEntities, checkedKeys, halfCheckedKeys) : (0, _treeUtil.calcCheckedKeysForUnchecked)(key, keyEntities, checkedKeys, halfCheckedKeys);
+  }
+
+  handleInputChange(sugInput) {
+    this._adapter.updateInputValue(sugInput);
+
+    const {
+      keyEntities
+    } = this.getStates();
+    const {
+      treeNodeFilterProp,
+      filterTreeNode,
+      filterLeafOnly
+    } = this.getProps();
+    let filteredKeys = [];
+
+    if (sugInput) {
+      var _context6, _context7, _context8;
+
+      filteredKeys = (0, _map.default)(_context6 = (0, _filter.default)(_context7 = (0, _filter.default)(_context8 = (0, _values.default)(keyEntities)).call(_context8, item => {
+        const {
+          key,
+          _notExist
+        } = item;
+
+        if (_notExist) {
+          return false;
+        }
+
+        const filteredPath = this.getItemPropPath(key, treeNodeFilterProp).join();
+        return (0, _filterInstanceProperty2(_treeUtil))(sugInput, filteredPath, filterTreeNode, false);
+      })).call(_context7, item => filterTreeNode && !filterLeafOnly || this._isLeaf(item))).call(_context6, item => item.key);
+    }
+
+    this._adapter.updateStates({
+      isSearching: Boolean(sugInput),
+      filteredKeys: new _set.default(filteredKeys)
+    });
+
+    this._adapter.notifyOnSearch(sugInput);
+  }
+
+  handleClear() {
+    const {
+      isSearching
+    } = this.getStates();
+    const {
+      searchPlaceholder,
+      placeholder,
+      multiple
+    } = this.getProps();
+
+    const isFilterable = this._isFilterable();
+
+    const isControlled = this._isControlledComponent();
+
+    const newState = {};
+
+    if (multiple) {
+      this._adapter.updateInputValue('');
+
+      this._adapter.notifyOnSearch('');
+
+      newState.checkedKeys = new _set.default([]);
+      newState.halfCheckedKeys = new _set.default([]);
+      newState.selectedKeys = new _set.default([]);
+      newState.activeKeys = new _set.default([]);
+      newState.mergedCheckedKeys = new _set.default([]);
+
+      this._adapter.notifyChange([]);
+    } else {
+      // if click clearBtn when not searching, clear selected and active values as well
+      if (isFilterable && isSearching) {
+        newState.isSearching = false;
+
+        this._adapter.updateInputValue('');
+
+        this._adapter.notifyOnSearch('');
+      } else {
+        if (isFilterable) {
+          newState.inputValue = '';
+          newState.inputPlaceHolder = searchPlaceholder || placeholder || '';
+
+          this._adapter.updateInputValue('');
+
+          this._adapter.notifyOnSearch('');
+        }
+
+        if (!isControlled) {
+          newState.selectedKeys = new _set.default([]);
+        }
+
+        newState.activeKeys = new _set.default([]);
+        newState.filteredKeys = new _set.default([]);
+
+        this._adapter.notifyChange([]);
+      }
+    }
+
+    this._adapter.updateStates(newState);
+
+    this._adapter.notifyClear();
+
+    this._adapter.rePositionDropdown();
+  }
+
+  getRenderData() {
+    var _context9, _context10;
+
+    const {
+      keyEntities,
+      isSearching
+    } = this.getStates();
+
+    const isFilterable = this._isFilterable();
+
+    if (isSearching && isFilterable) {
+      return this.getFilteredData();
+    }
+
+    return (0, _sort.default)(_context9 = (0, _filter.default)(_context10 = (0, _values.default)(keyEntities)).call(_context10, item => item.parentKey === null && !item._notExist) // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    ).call(_context9, (a, b) => (0, _parseInt2.default)(a.ind, 10) - (0, _parseInt2.default)(b.ind, 10));
+  }
+
+  getFilteredData() {
+    const {
+      treeNodeFilterProp
+    } = this.getProps();
+    const {
+      filteredKeys,
+      keyEntities
+    } = this.getStates();
+    const filteredList = [];
+    const filteredKeyArr = [...filteredKeys];
+    (0, _forEach.default)(filteredKeyArr).call(filteredKeyArr, key => {
+      const item = keyEntities[key];
+
+      if (!item) {
+        return;
+      }
+
+      const itemSearchPath = this.getItemPropPath(key, treeNodeFilterProp);
+
+      const isDisabled = this._isOptionDisabled(key, keyEntities);
+
+      filteredList.push({
+        data: item.data,
+        key,
+        disabled: isDisabled,
+        searchText: itemSearchPath
+      });
+    });
+    return filteredList;
+  }
+
+  handleListScroll(e, ind) {
+    const {
+      activeKeys,
+      keyEntities
+    } = this.getStates();
+    const lastActiveKey = [...activeKeys][activeKeys.size - 1];
+    const data = lastActiveKey ? (0, _get2.default)(keyEntities, [lastActiveKey, 'data'], null) : null;
+
+    this._adapter.notifyListScroll(e, {
+      panelIndex: ind,
+      activeNode: data
+    });
+  }
+
+  handleTagRemove(e, tagValuePath) {
+    var _context11;
+
+    const {
+      keyEntities
+    } = this.getStates();
+    const {
+      disabled
+    } = this.getProps();
+
+    if (disabled) {
+      return;
+    }
+
+    const removedItem = (0, _filter.default)(_context11 = (0, _values.default)(keyEntities)).call(_context11, item => (0, _isEqual2.default)(item.valuePath, tagValuePath))[0];
+    !(0, _isEmpty2.default)(removedItem) && !removedItem.data.disabled && this._handleMultipleSelect(removedItem);
+  }
+
+}
+
+exports.default = CascaderFoundation;