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

package/lib/cjs/cascader/util.js

@@ -3,27 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.calcCheckedKeys = calcCheckedKeys;
-exports.calcCheckedKeysForChecked = calcCheckedKeysForChecked;
-exports.calcCheckedKeysForUnchecked = calcCheckedKeysForUnchecked;
-exports.calcDisabledKeys = calcDisabledKeys;
 exports.calcMergeType = calcMergeType;
 exports.convertDataToEntities = convertDataToEntities;
-exports.findAncestorKeys = findAncestorKeys;
-exports.findChildKeys = findChildKeys;
-exports.findDescendantKeys = findDescendantKeys;
 exports.findKeysForValues = findKeysForValues;
-exports.findSiblingKeys = findSiblingKeys;
 exports.isValid = isValid;
-exports.normalizeKeyList = normalizeKeyList;
 exports.normalizedArr = normalizedArr;
 
-var _max2 = _interopRequireDefault(require("lodash/max"));
-
-var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
-
-var _uniq2 = _interopRequireDefault(require("lodash/uniq"));
-
 var _isEqual2 = _interopRequireDefault(require("lodash/isEqual"));
 
 var _isUndefined2 = _interopRequireDefault(require("lodash/isUndefined"));
@@ -32,21 +17,8 @@ var _isNull2 = _interopRequireDefault(require("lodash/isNull"));
 
 var _constants = require("./constants");
 
-var _treeUtil = require("../tree/treeUtil");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var __rest = void 0 && (void 0).__rest || function (s, e) {
-  var t = {};
-
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-
-  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-  }
-  return t;
-};
-
 function getPosition(level, index) {
   return "".concat(level, "-").concat(index);
 }
@@ -74,14 +46,8 @@ function traverseDataNodes(treeNodes, callback) {
 
     if (node) {
       const key = parent ? getPosition(parent.key, ind) : "".concat(ind);
-
-      const {
-        children
-      } = node,
-            resetInfo = __rest(node, ["children"]);
-
       item = {
-        data: Object.assign({}, resetInfo),
+        data: Object.assign({}, node),
         ind,
         key,
         level: parent ? parent.level + 1 : 0,
@@ -112,19 +78,12 @@ function convertDataToEntities(dataNodes) {
     } = data;
     const entity = Object.assign({}, data);
     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];
+    entity.parent = keyEntities[parentKey];
 
-    if (entityParent) {
-      // entityParent.children = entityParent.children || [];
-      // entityParent.children.push(entity);
-      entityParent.childrenKeys = entityParent.childrenKeys || [];
-      entityParent.childrenKeys.push(key);
+    if (entity.parent) {
+      entity.parent.children = entity.parent.children || [];
+      entity.parent.children.push(entity);
     }
   });
   return keyEntities;
@@ -148,312 +107,4 @@ function calcMergeType(autoMergeValue, leafOnly) {
   }
 
   return mergeType;
-}
-
-function findChildKeys(keys, options) {
-  let omitKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  const res = [];
-  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 => {
-      if (!omitKeys.length || !omitKeys.includes(child.key)) {
-        res.push(child.key);
-      }
-    });
-  });
-  return res;
-}
-
-function findSiblingKeys(selectedKeys, options) {
-  let self = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  const par = []; // 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((0, _uniq2.default)(par), options, self ? [] : selectedKeys);
-  return res;
-}
-
-function findAncestorKeys(selectedKeys, options) {
-  let self = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  const res = []; // Recursively find the parent element
-  // const findPar = (item: any) => {
-  //     if (item.parent) {
-  //         res.push(item.parent.key);
-  //         findPar(item.parent);
-  //     }
-  // };
-
-  const findPar = item => {
-    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;
-}
-
-function calcCheckedKeysForUnchecked(key, keyEntities, checkedKeys, halfCheckedKeys) {
-  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 => {
-    // 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
-  };
-}
-
-function calcCheckedKeysForChecked(key, keyEntities, checkedKeys, halfCheckedKeys) {
-  const descendantKeys = findDescendantKeys([key], keyEntities, true);
-  const nodeItem = keyEntities[key];
-  checkedKeys = new Set([...checkedKeys, key]);
-
-  const calcCurrLevel = node => {
-    // 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
-  };
-}
-
-function calcCheckedKeys(values, 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 = [];
-  const levelMap = (0, _treeUtil.getSortedKeyList)(keyList, keyEntities);
-
-  const calcCurrLevel = node => {
-    // 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 => 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 (!(0, _isEmpty2.default)(levelMap)) {
-    const maxLevel = (0, _max2.default)(Object.keys(levelMap).map(key => Number(key)));
-    levelMap[maxLevel].forEach(key => calcCurrLevel(keyEntities[key]));
-    delete levelMap[maxLevel];
-  }
-
-  return {
-    checkedKeys,
-    halfCheckedKeys
-  };
-}
-
-function findDescendantKeys(selectedKeys, options) {
-  let self = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  const res = [];
-
-  const findChild = item => {
-    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 => {
-        res.push(childKey);
-        findChild(options[childKey]);
-      });
-    }
-  };
-
-  selectedKeys.forEach(item => {
-    if (self) {
-      res.push(item);
-    }
-
-    findChild(options[item]);
-  });
-  return res;
-}
-
-function normalizeKeyList(keyList, keyEntities) {
-  let leafOnly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  const res = [];
-  const keyListSet = new Set(keyList);
-
-  if (!leafOnly) {
-    keyList.forEach(key => {
-      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;
-}
-
-function calcDisabledKeys(keyEntities) {
-  const disabledKeys = Object.keys(keyEntities).filter(key => keyEntities[key].data.disabled);
-  const {
-    checkedKeys
-  } = calcCheckedKeys(disabledKeys, keyEntities);
-  return checkedKeys;
 }

package/lib/cjs/tree/treeUtil.d.ts

@@ -38,7 +38,6 @@ export declare function findChildKeys(keys: string[], options: any, omitKeys?: a
 export declare function findLeafKeys(keys: string[], options: 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 getSortedKeyList(keyList: any[], keyEntities: KeyEntities): {};
 export declare function calcCheckedKeys(values: any, keyEntities: KeyEntities): {
     checkedKeys: Set<string>;
     halfCheckedKeys: Set<any>;

package/lib/cjs/tree/treeUtil.js

@@ -25,7 +25,6 @@ exports.findSiblingKeys = findSiblingKeys;
 exports.flattenTreeData = flattenTreeData;
 exports.getDragNodesKeys = getDragNodesKeys;
 exports.getMotionKeys = getMotionKeys;
-exports.getSortedKeyList = getSortedKeyList;
 exports.getValueOrKey = getValueOrKey;
 exports.normalizeKeyList = normalizeKeyList;
 exports.normalizeValue = normalizeValue;

package/lib/es/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/es/cascader/foundation.js

@@ -8,8 +8,8 @@ import _difference from "lodash/difference";
 import _get from "lodash/get";
 import _isEqual from "lodash/isEqual";
 import BaseFoundation from '../base/foundation';
-import { filter } from '../tree/treeUtil';
-import { convertDataToEntities, findKeysForValues, normalizedArr, isValid, calcMergeType, findAncestorKeys, calcCheckedKeysForUnchecked, calcCheckedKeysForChecked, calcCheckedKeys, findDescendantKeys, normalizeKeyList } from './util';
+import { filter, findAncestorKeys, calcCheckedKeysForUnchecked, calcCheckedKeysForChecked, calcCheckedKeys, findDescendantKeys, normalizeKeyList } from '../tree/treeUtil';
+import { convertDataToEntities, findKeysForValues, normalizedArr, isValid, calcMergeType } from './util';
 import { strings } from './constants';
 import isEnterPress from '../utils/isEnterPress'; // eslint-disable-next-line max-len
 
@@ -67,25 +67,14 @@ export default class CascaderFoundation extends BaseFoundation {
 
       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() {
@@ -280,9 +269,8 @@ export default class CascaderFoundation extends BaseFoundation {
        * 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) {
@@ -473,7 +461,7 @@ export default class CascaderFoundation extends BaseFoundation {
       key
     } = item;
 
-    const isLeaf = this._isLeaf(item);
+    const isLeaf = this._isLeaf(data);
 
     const activeKeys = keyEntities[key].path;
 
@@ -579,10 +567,9 @@ export default class CascaderFoundation extends BaseFoundation {
 
     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
@@ -627,9 +614,9 @@ export default class CascaderFoundation extends BaseFoundation {
     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];
@@ -874,8 +861,7 @@ export default class CascaderFoundation extends BaseFoundation {
 
         const filteredPath = this.getItemPropPath(key, treeNodeFilterProp).join();
         return 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({
@@ -1004,8 +990,7 @@ export default class CascaderFoundation extends BaseFoundation {
         data: item.data,
         key,
         disabled: isDisabled,
-        searchText: itemSearchPath,
-        childrenKeys: item.childrenKeys
+        searchText: itemSearchPath
       });
     });
     return filteredList;

package/lib/es/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>;