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

package/cascader/foundation.ts

@@ -1,21 +1,23 @@
 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 {
-    filter,
+    convertDataToEntities,
+    findKeysForValues,
+    normalizedArr,
+    isValid,
+    calcMergeType,
     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';
@@ -24,7 +26,8 @@ export interface BasicData {
     data: BasicCascaderData;
     disabled: boolean;
     key: string;
-    searchText: any[]
+    searchText: any[];
+    childrenKeys?: string[]
 }
 
 export interface BasicEntities {
@@ -35,6 +38,7 @@ export interface BasicEntity {
     _notExist?: boolean;
     /* children list */
     children?: Array<BasicEntity>;
+    childrenKeys?: string[];
     /* treedata */
     data: BasicCascaderData;
     /* index */
@@ -60,7 +64,8 @@ export interface BasicCascaderData {
     disabled?: boolean;
     isLeaf?: boolean;
     loading?: boolean;
-    children?: BasicCascaderData[]
+    children?: BasicCascaderData[];
+    childrenKeys?: string[]
 }
 
 export type CascaderType = 'large' | 'small' | 'default';
@@ -262,11 +267,19 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
         }
     }
 
-    _isLeaf(item: BasicCascaderData) {
+    // _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;
         if (this.getProp('loadData')) {
-            return Boolean(item.isLeaf);
+            return Boolean(data.isLeaf);
         }
-        return !item.children || !item.children.length;
+        return !childrenKeys || !childrenKeys;
     }
 
     _clearInput() {
@@ -430,7 +443,8 @@ 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.data)) {
+            if (changeOnSelect || this._isLeaf(selectedItem)) {
                 updateStates.selectedKeys = new Set([selectedKey]);
                 if (!loadingActive.length) {
                     updateStates.activeKeys = new Set(selectedItem.path);
@@ -574,7 +588,7 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
     handleShowNextByHover(item: BasicEntity) {
         const { keyEntities } = this.getStates();
         const { data, key } = item;
-        const isLeaf = this._isLeaf(data);
+        const isLeaf = this._isLeaf(item);
         const activeKeys = keyEntities[key].path;
         this._adapter.updateStates({
             activeKeys: new Set(activeKeys)
@@ -657,7 +671,8 @@ 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.children && this.getProp('loadData')) {
+        if (!data.isLeaf && !data.childrenKeys && this.getProp('loadData')) {
             const { loadedKeys, loadingKeys } = this.getCopyFromState(['loadedKeys', 'loadingKeys']);
             if (loadedKeys.has(key) || loadingKeys.has(key)) {
                 return;
@@ -676,7 +691,8 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
         const filterable = this._isFilterable();
         const { data, key } = item;
 
-        const isLeaf = this._isLeaf(data);
+        // const isLeaf = this._isLeaf(data);
+        const isLeaf = this._isLeaf(item);
 
         const activeKeys = keyEntities[key].path;
         const selectedKey = [key];
@@ -872,7 +888,8 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
                 })
                 .filter(
                     item => (filterTreeNode && !filterLeafOnly) ||
-                    this._isLeaf(item as unknown as BasicCascaderData)
+                    // this._isLeaf(item.data)
+                    this._isLeaf(item)
                 )
                 .map(item => item.key);
         }
@@ -942,6 +959,7 @@ 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
@@ -965,7 +983,8 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
                 data: item.data,
                 key,
                 disabled: isDisabled,
-                searchText: itemSearchPath
+                searchText: itemSearchPath,
+                childrenKeys: item.childrenKeys,
             });
         });
         return filteredList;

package/cascader/util.ts

@@ -1,10 +1,15 @@
 import {
     isNull,
     isUndefined,
-    isEqual
+    isEqual,
+    uniq,
+    isEmpty,
+    max
 } from 'lodash';
 import { strings } from './constants';
 
+import { KeyEntities, getSortedKeyList } from '../tree/treeUtil';
+
 function getPosition(level: any, index: any) {
     return `${level}-${index}`;
 }
@@ -31,8 +36,9 @@ 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: { ...node },
+                data: { ...resetInfo },
                 ind,
                 key,
                 level: parent ? parent.level + 1 : 0,
@@ -65,10 +71,17 @@ 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);
+        // 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);
         }
     });
     return keyEntities;
@@ -92,4 +105,273 @@ 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/datePicker/yearAndMonthFoundation.ts

@@ -1,3 +1,4 @@
+import { setMonth, setYear } from 'date-fns';
 import BaseFoundation, { DefaultAdapter } from '../base/foundation';
 import { PresetPosition } from './foundation';
 
@@ -26,7 +27,7 @@ export interface YearAndMonthFoundationState {
     currentMonth: number
 }
 export interface YearAndMonthAdapter extends DefaultAdapter<YearAndMonthFoundationProps, YearAndMonthFoundationState> {
-    setCurrentYear: (currentYear: number) => void;
+    setCurrentYear: (currentYear: number, cb?: () => void) => void;
     setCurrentMonth: (currentMonth: number) => void;
     notifySelectYear: (year: number) => void;
     notifySelectMonth: (month: number) => void;
@@ -61,7 +62,7 @@ export default class YearAndMonthFoundation extends BaseFoundation<YearAndMonthA
 
     selectYear(item: YearScrollItem) {
         const year = item.value;
-        this._adapter.setCurrentYear(year);
+        this._adapter.setCurrentYear(year, () => this.autoSelectMonth(item));
         this._adapter.notifySelectYear(year);
     }
 
@@ -71,6 +72,29 @@ export default class YearAndMonthFoundation extends BaseFoundation<YearAndMonthA
         this._adapter.notifySelectMonth(month);
     }
 
+    /**
+     * After selecting a year, if the currentMonth is disabled, automatically select a non-disabled month
+     */
+    autoSelectMonth(item: YearScrollItem) {
+        const { disabledDate, locale } = this._adapter.getProps();
+        const { months, currentMonth } = this._adapter.getStates();
+
+        const currentDate = setYear(Date.now(), item.year);
+        const isCurrentMonthDisabled = disabledDate(setMonth(currentDate, currentMonth - 1));
+        if (isCurrentMonthDisabled) {
+            const currentIndex = months.findIndex(({ month }) => month === currentMonth);
+            let validMonth: typeof months[number];
+            // First look in the back, if you can't find it in the back, then look in the front
+            validMonth = months.slice(currentIndex).find(({ month }) => !disabledDate(setMonth(currentDate, month - 1)));
+            if (!validMonth) {
+                validMonth = months.slice(0, currentIndex).find(({ month }) => !disabledDate(setMonth(currentDate, month - 1)));
+            }
+            if (validMonth) {
+                this.selectMonth({ month: validMonth.month, value: locale.fullMonths[validMonth.month], disabled: false });
+            }
+        }
+    }
+
     backToMain() {
         this._adapter.notifyBackToMain();
     }

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

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