@douyinfe/semi-foundation 2.24.1-alpha.0 → 2.24.2

package/cascader/foundation.ts

@@ -1,23 +1,21 @@
 import { isEqual, get, difference, isUndefined, assign, cloneDeep, isEmpty, isNumber, includes } from 'lodash';
 import BaseFoundation, { DefaultAdapter } from '../base/foundation';
-import { filter } from '../tree/treeUtil';
-import { Motion } from '../utils/type';
 import {
-    convertDataToEntities,
-    findKeysForValues,
-    normalizedArr,
-    isValid,
-    calcMergeType,
+    filter,
     findAncestorKeys,
-    
     calcCheckedKeysForUnchecked,
-
     calcCheckedKeysForChecked,
-
     calcCheckedKeys,
-
     findDescendantKeys,
     normalizeKeyList
+} from '../tree/treeUtil';
+import { Motion } from '../utils/type';
+import {
+    convertDataToEntities,
+    findKeysForValues,
+    normalizedArr,
+    isValid,
+    calcMergeType
 } from './util';
 import { strings } from './constants';
 import isEnterPress from '../utils/isEnterPress';
@@ -26,8 +24,7 @@ export interface BasicData {
     data: BasicCascaderData;
     disabled: boolean;
     key: string;
-    searchText: any[];
-    childrenKeys?: string[]
+    searchText: any[]
 }
 
 export interface BasicEntities {
@@ -38,7 +35,6 @@ export interface BasicEntity {
     _notExist?: boolean;
     /* children list */
     children?: Array<BasicEntity>;
-    childrenKeys?: string[];
     /* treedata */
     data: BasicCascaderData;
     /* index */
@@ -64,8 +60,7 @@ export interface BasicCascaderData {
     disabled?: boolean;
     isLeaf?: boolean;
     loading?: boolean;
-    children?: BasicCascaderData[];
-    childrenKeys?: string[]
+    children?: BasicCascaderData[]
 }
 
 export type CascaderType = 'large' | 'small' | 'default';
@@ -267,19 +262,11 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
         }
     }
 
-    // _isLeaf(item: BasicCascaderData) {
-    //     if (this.getProp('loadData')) {
-    //         return Boolean(item.isLeaf);
-    //     }
-    //     return !item.children || !item.children.length;
-    // }
-
-    _isLeaf(item: BasicEntity | BasicData) {
-        const { data, childrenKeys } = item;
+    _isLeaf(item: BasicCascaderData) {
         if (this.getProp('loadData')) {
-            return Boolean(data.isLeaf);
+            return Boolean(item.isLeaf);
         }
-        return !childrenKeys || !childrenKeys;
+        return !item.children || !item.children.length;
     }
 
     _clearInput() {
@@ -443,8 +430,7 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
              * 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)) {
-            if (changeOnSelect || this._isLeaf(selectedItem)) {
+            if (changeOnSelect || this._isLeaf(selectedItem.data)) {
                 updateStates.selectedKeys = new Set([selectedKey]);
                 if (!loadingActive.length) {
                     updateStates.activeKeys = new Set(selectedItem.path);
@@ -588,7 +574,7 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
     handleShowNextByHover(item: BasicEntity) {
         const { keyEntities } = this.getStates();
         const { data, key } = item;
-        const isLeaf = this._isLeaf(item);
+        const isLeaf = this._isLeaf(data);
         const activeKeys = keyEntities[key].path;
         this._adapter.updateStates({
             activeKeys: new Set(activeKeys)
@@ -671,8 +657,7 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
     notifyIfLoadData(item: BasicEntity | BasicData) {
         const { data, key } = item;
         this._adapter.updateStates({ loading: false });
-        // if (!data.isLeaf && !data.children && this.getProp('loadData')) {
-        if (!data.isLeaf && !data.childrenKeys && this.getProp('loadData')) {
+        if (!data.isLeaf && !data.children && this.getProp('loadData')) {
             const { loadedKeys, loadingKeys } = this.getCopyFromState(['loadedKeys', 'loadingKeys']);
             if (loadedKeys.has(key) || loadingKeys.has(key)) {
                 return;
@@ -691,8 +676,7 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
         const filterable = this._isFilterable();
         const { data, key } = item;
 
-        // const isLeaf = this._isLeaf(data);
-        const isLeaf = this._isLeaf(item);
+        const isLeaf = this._isLeaf(data);
 
         const activeKeys = keyEntities[key].path;
         const selectedKey = [key];
@@ -888,8 +872,7 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
                 })
                 .filter(
                     item => (filterTreeNode && !filterLeafOnly) ||
-                    // this._isLeaf(item.data)
-                    this._isLeaf(item)
+                    this._isLeaf(item as unknown as BasicCascaderData)
                 )
                 .map(item => item.key);
         }
@@ -959,7 +942,6 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
         if (isSearching && isFilterable) {
             return this.getFilteredData();
         }
-       
         return (Object.values(keyEntities) as BasicEntity[])
             .filter(item => item.parentKey === null && !item._notExist)
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -983,8 +965,7 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
                 data: item.data,
                 key,
                 disabled: isDisabled,
-                searchText: itemSearchPath,
-                childrenKeys: item.childrenKeys,
+                searchText: itemSearchPath
             });
         });
         return filteredList;

package/cascader/util.ts

@@ -1,15 +1,10 @@
 import {
     isNull,
     isUndefined,
-    isEqual,
-    uniq,
-    isEmpty,
-    max
+    isEqual
 } from 'lodash';
 import { strings } from './constants';
 
-import { KeyEntities, getSortedKeyList } from '../tree/treeUtil';
-
 function getPosition(level: any, index: any) {
     return `${level}-${index}`;
 }
@@ -36,9 +31,8 @@ function traverseDataNodes(treeNodes: any, callback: any) {
         // Process node if is not root
         if (node) {
             const key = parent ? getPosition(parent.key, ind) : `${ind}`;
-            const { children, ...resetInfo } = node;
             item = {
-                data: { ...resetInfo },
+                data: { ...node },
                 ind,
                 key,
                 level: parent ? parent.level + 1 : 0,
@@ -71,17 +65,10 @@ export function convertDataToEntities(dataNodes: any) {
         keyEntities[key] = entity;
 
         // Fill children
-        // entity.parent = keyEntities[parentKey];
-        // if (entity.parent) {
-        //     entity.parent.children = entity.parent.children || [];
-        //     entity.parent.children.push(entity);
-        // }
-        const entityParent = keyEntities[parentKey];
-        if (entityParent) {
-            // entityParent.children = entityParent.children || [];
-            // entityParent.children.push(entity);
-            entityParent.childrenKeys = entityParent.childrenKeys || [];
-            entityParent.childrenKeys.push(key);
+        entity.parent = keyEntities[parentKey];
+        if (entity.parent) {
+            entity.parent.children = entity.parent.children || [];
+            entity.parent.children.push(entity);
         }
     });
     return keyEntities;
@@ -105,273 +92,4 @@ export function calcMergeType(autoMergeValue: boolean, leafOnly: boolean): strin
         mergeType = strings.NONE_MERGE_TYPE;
     }
     return mergeType;
-}
-
-export function findChildKeys(keys: string[], options: any, omitKeys: any[] = []) {
-    const res: any[] = [];
-    keys &&
-        keys.forEach(key => {
-            const opts = options[key];
-            // opts &&
-            //     opts.children &&
-            //     opts.children.forEach((child: any) => {
-            //         if (!omitKeys.length || !omitKeys.includes(child.key)) {
-            //             res.push(child.key);
-            //         }
-            //     });
-            opts &&
-                opts.childrenKeys &&
-                opts.childrenKeys.forEach((child: any) => {
-                    if (!omitKeys.length || !omitKeys.includes(child.key)) {
-                        res.push(child.key);
-                    }
-                });
-        });
-    return res;
-}
-
-export function findSiblingKeys(selectedKeys: string[], options: any, self = true) {
-    const par: any[] = [];
-    // selectedKeys.forEach(item => {
-    //     if (options[item] && options[item].parent) {
-    //         par.push(options[item].parent.key);
-    //     }
-    // });
-    selectedKeys.forEach(item => {
-        if (options[item] && options[item].parentKey) {
-            par.push(options[item].parentKey);
-        }
-    });
-    
-
-    const res = findChildKeys(uniq(par), options, self ? [] : selectedKeys);
-    return res;
-}
-
-export function findAncestorKeys(selectedKeys: string[], options: any, self = true) {
-    const res: any[] = [];
-    // Recursively find the parent element
-    // const findPar = (item: any) => {
-    //     if (item.parent) {
-    //         res.push(item.parent.key);
-    //         findPar(item.parent);
-    //     }
-    // };
-    const findPar = (item: any) => {
-        if (item.parentKey) {
-            res.push(item.parentKey);
-            findPar(options[item.parentKey]);
-        }
-    };
-    selectedKeys.forEach(item => {
-        options[item] && findPar(options[item]);
-        if (self) {
-            res.push(item);
-        }
-    });
-    return res;
-}
-
-export function calcCheckedKeysForUnchecked(key: string, keyEntities: KeyEntities, checkedKeys: Set<string>, halfCheckedKeys: Set<string>) {
-    const descendantKeys = findDescendantKeys([key], keyEntities, true);
-    const nodeItem = keyEntities[key];
-    descendantKeys.forEach(descendantKey => {
-        if (checkedKeys.has(descendantKey)) {
-            checkedKeys.delete(descendantKey);
-        }
-        if (halfCheckedKeys.has(descendantKey)) {
-            halfCheckedKeys.delete(descendantKey);
-        }
-    });
-    const calcCurrLevel = (node: any) => {
-        // const par = node.parent;
-        const par = keyEntities[node.parentKey];
-        // no parent
-        if (!par) {
-            return;
-        }
-        // Has a parent node, and the parent node is not checked or halfChecked
-        if (!checkedKeys.has(par.key) && !halfCheckedKeys.has(par.key)) {
-            return;
-        }
-        // Has a parent node, and the parent node is checked or halfChecked
-        // eslint-disable-next-line @typescript-eslint/no-shadow
-        const { key } = node;
-        const siblingKeys = findSiblingKeys([key], keyEntities);
-        // eslint-disable-next-line @typescript-eslint/no-shadow
-        const anyChecked = siblingKeys.some(key => checkedKeys.has(key) || halfCheckedKeys.has(key));
-        const ancestorKeys = findAncestorKeys([key], keyEntities, false);
-        // If there is checked or halfChecked in the sibling node, you need to change the parent node to halfChecked
-        if (anyChecked) {
-            ancestorKeys.forEach(itemKey => {
-                if (checkedKeys.has(itemKey)) {
-                    checkedKeys.delete(itemKey);
-                    halfCheckedKeys.add(itemKey);
-                }
-            });
-            // If there is no checked or halfChecked in the sibling node, you need to change the parent node to unchecked
-        } else {
-            if (checkedKeys.has(par.key)) {
-                checkedKeys.delete(par.key);
-            }
-            if (halfCheckedKeys.has(par.key)) {
-                halfCheckedKeys.delete(par.key);
-            }
-            calcCurrLevel(par);
-        }
-    };
-    calcCurrLevel(nodeItem);
-    return {
-        checkedKeys,
-        halfCheckedKeys,
-    };
-}
-
-export function calcCheckedKeysForChecked(key: string, keyEntities: KeyEntities, checkedKeys: Set<string>, halfCheckedKeys: Set<string>) {
-    const descendantKeys = findDescendantKeys([key], keyEntities, true);
-    const nodeItem = keyEntities[key];
-    checkedKeys = new Set([...checkedKeys, key]);
-    const calcCurrLevel = (node: any) => {
-        // if (!node.parent) {
-        //     return;
-        // }
-        const par = keyEntities[node.parentKey];
-        if (!par) {
-            return;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-shadow
-        const { key } = node;
-        const siblingKeys = findSiblingKeys([key], keyEntities);
-        // eslint-disable-next-line @typescript-eslint/no-shadow
-        const allChecked = siblingKeys.every(key => checkedKeys.has(key));
-        if (!allChecked) {
-            const ancestorKeys = findAncestorKeys([key], keyEntities, false);
-            halfCheckedKeys = new Set([...halfCheckedKeys, ...ancestorKeys]);
-        } else {
-            // const par = node.parent;
-            checkedKeys.add(par.key);
-            calcCurrLevel(par);
-        }
-    };
-    calcCurrLevel(nodeItem);
-    return {
-        checkedKeys: new Set([...checkedKeys, ...descendantKeys]),
-        halfCheckedKeys,
-    };
-}
-
-export function calcCheckedKeys(values: any, keyEntities: KeyEntities) {
-    const keyList = Array.isArray(values) ? values : [values];
-    const descendantKeys = findDescendantKeys(keyList, keyEntities, true);
-    /**
-     * Recursively find the parent element. Because the incoming nodes are all checked,
-     * their descendants must be checked. That is to say, if the descendant nodes have
-     *  disabled+unchecked nodes, their ancestor nodes will definitely not be checked
-     */
-    const checkedKeys = new Set([...descendantKeys]);
-    let halfCheckedKeys = new Set([]);
-    let visited: any[] = [];
-
-    const levelMap:{[key: number]: string[]} = getSortedKeyList(keyList, keyEntities);
-
-    const calcCurrLevel = (node: any) => {
-        // const { key, parent, level } = node;
-        const { key, parentKey, level } = node;
-        const parent = keyEntities[parentKey];
-        // If the node does not have a parent node, or the node has been processed just now, no processing is done
-        if (!parent || visited.includes(key)) {
-            return;
-        }
-
-        const siblingKeys = findSiblingKeys([key], keyEntities);
-        // visited for caching to avoid double counting
-        visited = [...visited, ...siblingKeys];
-        const allChecked = siblingKeys.every((siblingKey: string) => checkedKeys.has(siblingKey));
-        if (!allChecked) {
-            const ancestorKeys = findAncestorKeys([key], keyEntities, false);
-            halfCheckedKeys = new Set([...halfCheckedKeys, ...ancestorKeys]);
-        } else {
-            checkedKeys.add(parent.key);
-            // IMPORTANT! parent level may not exist in original level map; if add to the end directly may destroy the hierarchical order
-            if (level - 1 in levelMap && level) {
-                levelMap[level - 1].push(parent.key);
-            } else {
-                levelMap[level - 1] = [parent.key];
-            }
-        }
-    };
-    // Loop keyList from deepest Level to topLevel, bottom up
-    while (!isEmpty(levelMap)) {
-        const maxLevel = max(Object.keys(levelMap).map(key => Number(key)));
-        levelMap[maxLevel].forEach((key: string) => calcCurrLevel(keyEntities[key]));
-        delete levelMap[maxLevel];
-    }
-
-    return {
-        checkedKeys,
-        halfCheckedKeys,
-    };
-}
-
-export function findDescendantKeys(selectedKeys: string[], options: KeyEntities, self = true) {
-    const res: string[] = [];
-    const findChild = (item: any) => {
-        if (!item) {
-            return;
-        }
-        // const { children } = item;
-        // const hasChildren = isValid(children);
-        // if (hasChildren) {
-        //     children.forEach((child: any) => {
-        //         res.push(child.key);
-        //         findChild(options[child.key]);
-        //     });
-        // }
-        const { childrenKeys } = item;
-        const hasChildren = isValid(childrenKeys);
-        if (hasChildren) {
-            childrenKeys.forEach((childKey: any) => {
-                res.push(childKey);
-                findChild(options[childKey]);
-            });
-        }
-    };
-    selectedKeys.forEach(item => {
-        if (self) {
-            res.push(item);
-        }
-        findChild(options[item]);
-    });
-    return res;
-}
-
-export function normalizeKeyList(keyList: any, keyEntities: KeyEntities, leafOnly = false) {
-    const res: string[] = [];
-    const keyListSet = new Set(keyList);
-    if (!leafOnly) {
-        keyList.forEach((key: string) => {
-            if (!keyEntities[key]) {
-                return;
-            }
-            const { parentKey } = keyEntities[key];
-            if (parentKey && keyListSet.has(parentKey)) {
-                return;
-            }
-            res.push(key);
-        });
-    } else {
-        keyList.forEach(key => {
-            // if (keyEntities[key] && !isValid(keyEntities[key].children)) {
-            if (keyEntities[key] && !isValid(keyEntities[key].childrenKeys)) {
-                res.push(key);
-            }
-        });
-    }
-    return res;
-}
-
-export function calcDisabledKeys(keyEntities: KeyEntities) {
-    const disabledKeys = Object.keys(keyEntities).filter(key => keyEntities[key].data.disabled);
-    const { checkedKeys } = calcCheckedKeys(disabledKeys, keyEntities);
-    return checkedKeys;
 }

package/lib/cjs/cascader/foundation.d.ts

@@ -4,7 +4,6 @@ export interface BasicData {
     disabled: boolean;
     key: string;
     searchText: any[];
-    childrenKeys?: string[];
 }
 export interface BasicEntities {
     [idx: string]: BasicEntity;
@@ -12,7 +11,6 @@ export interface BasicEntities {
 export interface BasicEntity {
     _notExist?: boolean;
     children?: Array<BasicEntity>;
-    childrenKeys?: string[];
     data: BasicCascaderData;
     ind: number;
     key: string;
@@ -30,7 +28,6 @@ export interface BasicCascaderData {
     isLeaf?: boolean;
     loading?: boolean;
     children?: BasicCascaderData[];
-    childrenKeys?: string[];
 }
 export declare type CascaderType = 'large' | 'small' | 'default';
 export declare type BasicSimpleValueType = string | number | BasicCascaderData;
@@ -174,7 +171,7 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
     _isDisabled(): any;
     _isFilterable(): boolean;
     _notifyChange(item: BasicEntity | BasicData | Set<string>): void;
-    _isLeaf(item: BasicEntity | BasicData): boolean;
+    _isLeaf(item: BasicCascaderData): boolean;
     _clearInput(): void;
     _notifyBlur(e: any): void;
     _notifyFocus(e: any): void;

package/lib/cjs/cascader/foundation.js

@@ -90,25 +90,14 @@ class CascaderFoundation extends _foundation.default {
 
       this._adapter.notifyChange(valuePath);
     }
-  } // _isLeaf(item: BasicCascaderData) {
-  //     if (this.getProp('loadData')) {
-  //         return Boolean(item.isLeaf);
-  //     }
-  //     return !item.children || !item.children.length;
-  // }
-
+  }
 
   _isLeaf(item) {
-    const {
-      data,
-      childrenKeys
-    } = item;
-
     if (this.getProp('loadData')) {
-      return Boolean(data.isLeaf);
+      return Boolean(item.isLeaf);
     }
 
-    return !childrenKeys || !childrenKeys;
+    return !item.children || !item.children.length;
   }
 
   _clearInput() {
@@ -128,7 +117,7 @@ class CascaderFoundation extends _foundation.default {
   }
 
   _isOptionDisabled(key, keyEntities) {
-    const isDisabled = (0, _util.findAncestorKeys)([key], keyEntities, true).some(item => keyEntities[item].data.disabled);
+    const isDisabled = (0, _treeUtil.findAncestorKeys)([key], keyEntities, true).some(item => keyEntities[item].data.disabled);
     return isDisabled;
   }
 
@@ -303,9 +292,8 @@ class CascaderFoundation extends _foundation.default {
        * 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)) {
 
-      if (changeOnSelect || this._isLeaf(selectedItem)) {
+      if (changeOnSelect || this._isLeaf(selectedItem.data)) {
         updateStates.selectedKeys = new Set([selectedKey]);
 
         if (!loadingActive.length) {
@@ -496,7 +484,7 @@ class CascaderFoundation extends _foundation.default {
       key
     } = item;
 
-    const isLeaf = this._isLeaf(item);
+    const isLeaf = this._isLeaf(data);
 
     const activeKeys = keyEntities[key].path;
 
@@ -602,10 +590,9 @@ class CascaderFoundation extends _foundation.default {
 
     this._adapter.updateStates({
       loading: false
-    }); // if (!data.isLeaf && !data.children && this.getProp('loadData')) {
-
+    });
 
-    if (!data.isLeaf && !data.childrenKeys && this.getProp('loadData')) {
+    if (!data.isLeaf && !data.children && this.getProp('loadData')) {
       const {
         loadedKeys,
         loadingKeys
@@ -650,9 +637,9 @@ class CascaderFoundation extends _foundation.default {
     const {
       data,
       key
-    } = item; // const isLeaf = this._isLeaf(data);
+    } = item;
 
-    const isLeaf = this._isLeaf(item);
+    const isLeaf = this._isLeaf(data);
 
     const activeKeys = keyEntities[key].path;
     const selectedKey = [key];
@@ -744,7 +731,7 @@ class CascaderFoundation extends _foundation.default {
     const mergeType = (0, _util.calcMergeType)(autoMergeValue, leafOnly);
     const isLeafOnlyMerge = mergeType === _constants.strings.LEAF_ONLY_MERGE_TYPE;
     const isNoneMerge = mergeType === _constants.strings.NONE_MERGE_TYPE;
-    const curResolvedCheckedKeys = new Set((0, _util.normalizeKeyList)(curCheckedKeys, keyEntities, isLeafOnlyMerge));
+    const curResolvedCheckedKeys = new Set((0, _treeUtil.normalizeKeyList)(curCheckedKeys, keyEntities, isLeafOnlyMerge));
     const curRealCheckedKeys = isNoneMerge ? curCheckedKeys : curResolvedCheckedKeys;
 
     if ((0, _isNumber2.default)(max)) {
@@ -804,7 +791,7 @@ class CascaderFoundation extends _foundation.default {
     const {
       checkedKeys
     } = this.getCopyFromState(['checkedKeys']);
-    const descendantKeys = (0, _util.normalizeKeyList)((0, _util.findDescendantKeys)([eventKey], keyEntities, false), keyEntities, true);
+    const descendantKeys = (0, _treeUtil.normalizeKeyList)((0, _treeUtil.findDescendantKeys)([eventKey], keyEntities, false), keyEntities, true);
     const hasDisabled = descendantKeys.some(key => disabledKeys.has(key));
 
     if (!hasDisabled) {
@@ -812,8 +799,8 @@ class CascaderFoundation extends _foundation.default {
     }
 
     const nonDisabled = descendantKeys.filter(key => !disabledKeys.has(key));
-    const newCheckedKeys = targetStatus ? [...nonDisabled, ...checkedKeys] : (0, _difference2.default)((0, _util.normalizeKeyList)([...checkedKeys], keyEntities, true), nonDisabled);
-    return (0, _util.calcCheckedKeys)(newCheckedKeys, keyEntities);
+    const newCheckedKeys = targetStatus ? [...nonDisabled, ...checkedKeys] : (0, _difference2.default)((0, _treeUtil.normalizeKeyList)([...checkedKeys], keyEntities, true), nonDisabled);
+    return (0, _treeUtil.calcCheckedKeys)(newCheckedKeys, keyEntities);
   }
 
   calcCheckedStatus(targetStatus, eventKey) {
@@ -826,7 +813,7 @@ class CascaderFoundation extends _foundation.default {
       keyEntities,
       disabledKeys
     } = this.getStates();
-    const descendantKeys = (0, _util.normalizeKeyList)((0, _util.findDescendantKeys)([eventKey], keyEntities, false), keyEntities, true);
+    const descendantKeys = (0, _treeUtil.normalizeKeyList)((0, _treeUtil.findDescendantKeys)([eventKey], keyEntities, false), keyEntities, true);
     const hasDisabled = descendantKeys.some(key => disabledKeys.has(key));
 
     if (!hasDisabled) {
@@ -868,7 +855,7 @@ class CascaderFoundation extends _foundation.default {
       checkedKeys,
       halfCheckedKeys
     } = this.getCopyFromState(['checkedKeys', 'halfCheckedKeys']);
-    return curCheckedStatus ? (0, _util.calcCheckedKeysForChecked)(key, keyEntities, checkedKeys, halfCheckedKeys) : (0, _util.calcCheckedKeysForUnchecked)(key, keyEntities, checkedKeys, halfCheckedKeys);
+    return curCheckedStatus ? (0, _treeUtil.calcCheckedKeysForChecked)(key, keyEntities, checkedKeys, halfCheckedKeys) : (0, _treeUtil.calcCheckedKeysForUnchecked)(key, keyEntities, checkedKeys, halfCheckedKeys);
   }
 
   handleInputChange(sugInput) {
@@ -897,8 +884,7 @@ class CascaderFoundation extends _foundation.default {
 
         const filteredPath = this.getItemPropPath(key, treeNodeFilterProp).join();
         return (0, _treeUtil.filter)(sugInput, filteredPath, filterTreeNode, false);
-      }).filter(item => filterTreeNode && !filterLeafOnly || // this._isLeaf(item.data)
-      this._isLeaf(item)).map(item => item.key);
+      }).filter(item => filterTreeNode && !filterLeafOnly || this._isLeaf(item)).map(item => item.key);
     }
 
     this._adapter.updateStates({
@@ -1027,8 +1013,7 @@ class CascaderFoundation extends _foundation.default {
         data: item.data,
         key,
         disabled: isDisabled,
-        searchText: itemSearchPath,
-        childrenKeys: item.childrenKeys
+        searchText: itemSearchPath
       });
     });
     return filteredList;

package/lib/cjs/cascader/util.d.ts

@@ -1,24 +1,5 @@
-import { KeyEntities } from '../tree/treeUtil';
 export declare function isValid(val: any): boolean;
 export declare function normalizedArr(val: any): any[];
 export declare function convertDataToEntities(dataNodes: any): any;
 export declare function findKeysForValues(value: any, keyEntities: any): any[];
 export declare function calcMergeType(autoMergeValue: boolean, leafOnly: boolean): string;
-export declare function findChildKeys(keys: string[], options: any, omitKeys?: any[]): any[];
-export declare function findSiblingKeys(selectedKeys: string[], options: any, self?: boolean): any[];
-export declare function findAncestorKeys(selectedKeys: string[], options: any, self?: boolean): any[];
-export declare function calcCheckedKeysForUnchecked(key: string, keyEntities: KeyEntities, checkedKeys: Set<string>, halfCheckedKeys: Set<string>): {
-    checkedKeys: Set<string>;
-    halfCheckedKeys: Set<string>;
-};
-export declare function calcCheckedKeysForChecked(key: string, keyEntities: KeyEntities, checkedKeys: Set<string>, halfCheckedKeys: Set<string>): {
-    checkedKeys: Set<string>;
-    halfCheckedKeys: Set<string>;
-};
-export declare function calcCheckedKeys(values: any, keyEntities: KeyEntities): {
-    checkedKeys: Set<string>;
-    halfCheckedKeys: Set<any>;
-};
-export declare function findDescendantKeys(selectedKeys: string[], options: KeyEntities, self?: boolean): string[];
-export declare function normalizeKeyList(keyList: any, keyEntities: KeyEntities, leafOnly?: boolean): string[];
-export declare function calcDisabledKeys(keyEntities: KeyEntities): Set<string>;