tntd 2.0.12 → 2.0.13

package/es/tntd-cascader/rc-cascader/OptionList/Column.js

@@ -39,47 +39,42 @@ export default function Column({
   } = React.useContext(CascaderContext);
   const hoverOpen = expandTrigger === 'hover';
   /** 单选情况下滚动到相应的位置 */
-
   React.useEffect(() => {
     let timer = null;
-
     if (ref.current && ref.current.scrollTo && !multiple && dropdownVisible) {
       const index = options.findIndex(it => it[fieldNames.value] === activeValue);
-
       if (index > 0 && !isNaN(index)) {
         timer = window.setTimeout(() => {
           ref.current.scrollTo((optionHeight || 36) * index);
         }, 5);
       }
     }
-
     return () => {
       if (timer) {
         window.clearTimeout(timer);
       }
-
       timer = null;
     };
-  }, [multiple, activeValue, options, fieldNames, dropdownVisible, optionHeight]); // ============================ Option ============================
-
+  }, [multiple, activeValue, options, fieldNames, dropdownVisible, optionHeight]);
+  // ============================ Option ============================
   const optionInfoList = React.useMemo(() => options.map(option => {
     var _a;
-
     const {
       disabled
     } = option;
     const searchOptions = option[SEARCH_MARK];
     const label = (_a = option[FIX_LABEL]) !== null && _a !== void 0 ? _a : option[fieldNames.label];
     const value = option[fieldNames.value];
-    const isMergedLeaf = isLeaf(option, fieldNames); // Get real value of option. Search option is different way.
-
-    const fullPath = searchOptions ? // @ts-ignore
+    const isMergedLeaf = isLeaf(option, fieldNames);
+    // Get real value of option. Search option is different way.
+    const fullPath = searchOptions ?
+    // @ts-ignore
     searchOptions.map(opt => opt[fieldNames.value]) : [...prevValuePath, value];
     const fullPathKey = toPathKey(fullPath);
-    const isLoading = loadingKeys.includes(fullPathKey); // >>>>> checked
-
-    const checked = checkedSet.has(fullPathKey); // >>>>> halfChecked
-
+    const isLoading = loadingKeys.includes(fullPathKey);
+    // >>>>> checked
+    const checked = checkedSet.has(fullPathKey);
+    // >>>>> halfChecked
     const halfChecked = halfCheckedSet.has(fullPathKey);
     return {
       disabled,
@@ -93,8 +88,8 @@ export default function Column({
       fullPath,
       fullPathKey
     };
-  }), [options, checkedSet, fieldNames, halfCheckedSet, loadingKeys, prevValuePath]); // ============================ Render ============================
-
+  }), [options, checkedSet, fieldNames, halfCheckedSet, loadingKeys, prevValuePath]);
+  // ============================ Render ============================
   return React.createElement("ul", {
     className: menuPrefixCls,
     role: "menu"
@@ -122,24 +117,20 @@ export default function Column({
       if (!disabled && (!hoverOpen || !isMergedLeaf)) {
         onActive(fullPath);
       }
-    }; // >>>>> Selection
-
-
+    };
+    // >>>>> Selection
     const triggerSelect = () => {
       if (isSelectable(option)) {
         onSelect(fullPath, isMergedLeaf);
       }
-    }; // >>>>> Title
-
-
+    };
+    // >>>>> Title
     let title;
-
     if (typeof option.title === 'string') {
       title = option.title;
     } else if (typeof label === 'string') {
       title = label;
     }
-
     return React.createElement("li", {
       key: fullPathKey,
       className: classNames(menuItemPrefixCls, {
@@ -156,7 +147,6 @@ export default function Column({
       "data-path-key": fullPathKey,
       onClick: () => {
         triggerOpenPath();
-
         if (!multiple || isMergedLeaf) {
           triggerSelect();
         }

package/es/tntd-cascader/rc-cascader/OptionList/index.js

@@ -11,7 +11,6 @@ import useActive from './useActive';
 import useKeyboard from './useKeyboard';
 const RefOptionList = React.forwardRef((props, ref) => {
   var _a, _b;
-
   const {
     prefixCls,
     multiple,
@@ -37,30 +36,26 @@ const RefOptionList = React.forwardRef((props, ref) => {
     renderItem,
     dropdownVisible
   } = React.useContext(CascaderContext);
-  const mergedPrefixCls = dropdownPrefixCls || prefixCls; // ========================= loadData =========================
-
+  const mergedPrefixCls = dropdownPrefixCls || prefixCls;
+  // ========================= loadData =========================
   const [loadingKeys, setLoadingKeys] = React.useState([]);
-
   const internalLoadData = valueCells => {
     // Do not load when search
     if (!loadData || searchValue) {
       return;
     }
-
     const optionList = toPathOptions(valueCells, options, fieldNames);
     const rawOptions = optionList.map(({
       option
     }) => option);
     const lastOption = rawOptions[rawOptions.length - 1];
-
     if (lastOption && !isLeaf(lastOption, fieldNames)) {
       const pathKey = toPathKey(valueCells);
       setLoadingKeys(keys => [...keys, pathKey]);
       loadData(rawOptions);
     }
-  }; // zombieJ: This is bad. We should make this same as `rc-tree` to use Promise instead.
-
-
+  };
+  // zombieJ: This is bad. We should make this same as `rc-tree` to use Promise instead.
   React.useEffect(() => {
     if (loadingKeys.length) {
       loadingKeys.forEach(loadingKey => {
@@ -69,25 +64,23 @@ const RefOptionList = React.forwardRef((props, ref) => {
           option
         }) => option);
         const lastOption = optionList[optionList.length - 1];
-
         if (!lastOption || lastOption[fieldNames.children] || isLeaf(lastOption, fieldNames)) {
           setLoadingKeys(keys => keys.filter(key => key !== loadingKey));
         }
       });
     }
-  }, [options, loadingKeys, fieldNames]); // ========================== Values ==========================
-
+  }, [options, loadingKeys, fieldNames]);
+  // ========================== Values ==========================
   const checkedSet = React.useMemo(() => new Set(toPathKeys(values)), [values]);
-  const halfCheckedSet = React.useMemo(() => new Set(toPathKeys(halfValues)), [halfValues]); // ====================== Accessibility =======================
-
-  const [activeValueCells, setActiveValueCells] = useActive(); // =========================== Path ===========================
-
+  const halfCheckedSet = React.useMemo(() => new Set(toPathKeys(halfValues)), [halfValues]);
+  // ====================== Accessibility =======================
+  const [activeValueCells, setActiveValueCells] = useActive();
+  // =========================== Path ===========================
   const onPathOpen = nextValueCells => {
-    setActiveValueCells(nextValueCells); // Trigger loadData
-
+    setActiveValueCells(nextValueCells);
+    // Trigger loadData
     internalLoadData(nextValueCells);
   };
-
   const isSelectable = option => {
     const {
       disabled
@@ -95,59 +88,49 @@ const RefOptionList = React.forwardRef((props, ref) => {
     const isMergedLeaf = isLeaf(option, fieldNames);
     return !disabled && (isMergedLeaf || changeOnSelect || multiple);
   };
-
   const onPathSelect = (valuePath, leaf, fromKeyboard = false) => {
     onSelect(valuePath);
-
     if (!multiple && (leaf || changeOnSelect && (expandTrigger === 'hover' || fromKeyboard))) {
       toggleOpen(false);
     }
-  }; // ========================== Option ==========================
-
-
+  };
+  // ========================== Option ==========================
   const mergedOptions = React.useMemo(() => {
     if (searchValue) {
       return searchOptions;
     }
-
     return options;
-  }, [searchValue, searchOptions, options]); // ========================== Column ==========================
-
+  }, [searchValue, searchOptions, options]);
+  // ========================== Column ==========================
   const optionColumns = React.useMemo(() => {
     const optionList = [{
       options: mergedOptions
     }];
     let currentList = mergedOptions;
-
     for (let i = 0; i < activeValueCells.length; i += 1) {
       const activeValueCell = activeValueCells[i];
       const currentOption = currentList.find(option => option[fieldNames.value] === activeValueCell);
       const subOptions = currentOption === null || currentOption === void 0 ? void 0 : currentOption[fieldNames.children];
-
       if (!(subOptions === null || subOptions === void 0 ? void 0 : subOptions.length)) {
         break;
       }
-
       currentList = subOptions;
       optionList.push({
         options: subOptions
       });
     }
-
     return optionList;
-  }, [mergedOptions, activeValueCells, fieldNames]); // ========================= Keyboard =========================
-
+  }, [mergedOptions, activeValueCells, fieldNames]);
+  // ========================= Keyboard =========================
   const onKeyboardSelect = (selectValueCells, option) => {
     if (isSelectable(option)) {
       onPathSelect(selectValueCells, isLeaf(option, fieldNames), true);
     }
   };
-
-  useKeyboard(ref, mergedOptions, fieldNames, activeValueCells, onPathOpen, onKeyboardSelect); // >>>>> Active Scroll
-
+  useKeyboard(ref, mergedOptions, fieldNames, activeValueCells, onPathOpen, onKeyboardSelect);
+  // >>>>> Active Scroll
   React.useEffect(() => {
     var _a;
-
     for (let i = 0; i < activeValueCells.length; i += 1) {
       const cellPath = activeValueCells.slice(0, i + 1);
       const cellKeyPath = toPathKey(cellPath);
@@ -158,9 +141,9 @@ const RefOptionList = React.forwardRef((props, ref) => {
         scrollIntoParentView(ele);
       }
     }
-  }, [activeValueCells]); // ========================== Render ==========================
+  }, [activeValueCells]);
+  // ========================== Render ==========================
   // >>>>> Empty
-
   const isEmpty = !((_b = (_a = optionColumns[0]) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.length);
   const emptyList = [{
     [fieldNames.value]: '__EMPTY__',
@@ -176,8 +159,8 @@ const RefOptionList = React.forwardRef((props, ref) => {
     halfCheckedSet,
     loadingKeys,
     isSelectable
-  }); // >>>>> Columns
-
+  });
+  // >>>>> Columns
   const mergedOptionColumns = isEmpty ? [{
     options: emptyList
   }] : optionColumns;
@@ -197,8 +180,8 @@ const RefOptionList = React.forwardRef((props, ref) => {
       activeValue: activeValue,
       renderItem: renderItem
     }));
-  }); // >>>>> Render
-
+  });
+  // >>>>> Render
   return React.createElement("div", {
     className: classNames(`${mergedPrefixCls}-menus`, {
       [`${mergedPrefixCls}-menu-empty`]: isEmpty,

package/es/tntd-cascader/rc-cascader/OptionList/useActive.js

@@ -5,7 +5,6 @@ import { useBaseProps } from 'rc-select';
 /**
  * Control the active open options path.
  */
-
 export default (() => {
   const {
     multiple,
@@ -13,19 +12,18 @@ export default (() => {
   } = useBaseProps();
   const {
     values
-  } = React.useContext(CascaderContext); // Record current dropdown active options
+  } = React.useContext(CascaderContext);
+  // Record current dropdown active options
   // This also control the open status
-
   const [activeValueCells, setActiveValueCells] = React.useState([]);
   React.useEffect(() => {
     if (open && !multiple) {
       const firstValueCells = values[0];
       setActiveValueCells(firstValueCells || []);
     }
-  },
-  /* eslint-disable react-hooks/exhaustive-deps */
+  }, /* eslint-disable react-hooks/exhaustive-deps */
   [open]
-  /* eslint-enable react-hooks/exhaustive-deps */
-  );
+  /* eslint-enable react-hooks/exhaustive-deps */);
+
   return [activeValueCells, setActiveValueCells];
 });

package/es/tntd-cascader/rc-cascader/OptionList/useKeyboard.js

@@ -15,49 +15,40 @@ export default ((ref, options, fieldNames, activeValueCells, setActiveValueCells
     let currentOptions = options;
     const mergedActiveIndexes = [];
     const mergedActiveValueCells = [];
-    const len = activeValueCells.length; // Fill validate active value cells and index
-
+    const len = activeValueCells.length;
+    // Fill validate active value cells and index
     for (let i = 0; i < len && currentOptions; i += 1) {
       // Mark the active index for current options
       const nextActiveIndex = currentOptions.findIndex(option => option[fieldNames.value] === activeValueCells[i]);
-
       if (nextActiveIndex === -1) {
         break;
       }
-
       activeIndex = nextActiveIndex;
       mergedActiveIndexes.push(activeIndex);
       mergedActiveValueCells.push(activeValueCells[i]);
       currentOptions = currentOptions[activeIndex][fieldNames.children];
-    } // Fill last active options
-
-
+    }
+    // Fill last active options
     let activeOptions = options;
-
     for (let i = 0; i < mergedActiveIndexes.length - 1; i += 1) {
       activeOptions = activeOptions[mergedActiveIndexes[i]][fieldNames.children];
     }
-
     return [mergedActiveValueCells, activeIndex, activeOptions];
-  }, [activeValueCells, fieldNames, options]); // Update active value cells and scroll to target element
-
+  }, [activeValueCells, fieldNames, options]);
+  // Update active value cells and scroll to target element
   const internalSetActiveValueCells = next => {
     setActiveValueCells(next);
-  }; // Same options offset
-
-
+  };
+  // Same options offset
   const offsetActiveOption = offset => {
     const len = lastActiveOptions.length;
     let currentIndex = lastActiveIndex;
-
     if (currentIndex === -1 && offset < 0) {
       currentIndex = len;
     }
-
     for (let i = 0; i < len; i += 1) {
       currentIndex = (currentIndex + offset + len) % len;
       const option = lastActiveOptions[currentIndex];
-
       if (option && !option.disabled) {
         const value = option[fieldNames.value];
         const nextActiveCells = validActiveValueCells.slice(0, -1).concat(value);
@@ -65,9 +56,8 @@ export default ((ref, options, fieldNames, activeValueCells, setActiveValueCells
         return;
       }
     }
-  }; // Different options offset
-
-
+  };
+  // Different options offset
   const prevColumn = () => {
     if (validActiveValueCells.length > 1) {
       const nextActiveCells = validActiveValueCells.slice(0, -1);
@@ -76,46 +66,37 @@ export default ((ref, options, fieldNames, activeValueCells, setActiveValueCells
       toggleOpen(false);
     }
   };
-
   const nextColumn = () => {
     var _a;
-
     const nextOptions = ((_a = lastActiveOptions[lastActiveIndex]) === null || _a === void 0 ? void 0 : _a[fieldNames.children]) || [];
     const nextOption = nextOptions.find(option => !option.disabled);
-
     if (nextOption) {
       const nextActiveCells = [...validActiveValueCells, nextOption[fieldNames.value]];
       internalSetActiveValueCells(nextActiveCells);
     }
   };
-
   React.useImperativeHandle(ref, () => ({
     // scrollTo: treeRef.current?.scrollTo,
     onKeyDown: event => {
       const {
         which
       } = event;
-
       switch (which) {
         // >>> Arrow keys
         case KeyCode.UP:
         case KeyCode.DOWN:
           {
             let offset = 0;
-
             if (which === KeyCode.UP) {
               offset = -1;
             } else if (which === KeyCode.DOWN) {
               offset = 1;
             }
-
             if (offset !== 0) {
               offsetActiveOption(offset);
             }
-
             break;
           }
-
         case KeyCode.LEFT:
           {
             if (rtl) {
@@ -123,10 +104,8 @@ export default ((ref, options, fieldNames, activeValueCells, setActiveValueCells
             } else {
               prevColumn();
             }
-
             break;
           }
-
         case KeyCode.RIGHT:
           {
             if (rtl) {
@@ -134,42 +113,34 @@ export default ((ref, options, fieldNames, activeValueCells, setActiveValueCells
             } else {
               nextColumn();
             }
-
             break;
           }
-
         case KeyCode.BACKSPACE:
           {
             if (!searchValue) {
               prevColumn();
             }
-
             break;
           }
         // >>> Select
-
         case KeyCode.ENTER:
           {
             if (validActiveValueCells.length) {
-              const option = lastActiveOptions[lastActiveIndex]; // Search option should revert back of origin options
-
+              const option = lastActiveOptions[lastActiveIndex];
+              // Search option should revert back of origin options
               const originOptions = (option === null || option === void 0 ? void 0 : option[SEARCH_MARK]) || [];
-
               if (originOptions.length) {
                 onKeyBoardSelect(originOptions.map(opt => opt[fieldNames.value]), originOptions[originOptions.length - 1]);
               } else {
                 onKeyBoardSelect(validActiveValueCells, lastActiveOptions[lastActiveIndex]);
               }
             }
-
             break;
           }
         // >>> Close
-
         case KeyCode.ESC:
           {
             toggleOpen(false);
-
             if (open) {
               event.stopPropagation();
             }

package/es/tntd-cascader/rc-cascader/hooks/useDisplayValues.js

@@ -4,39 +4,33 @@ import * as React from 'react';
 import { toPathKey } from '../utils/commonUtil';
 export default ((rawValues, options, fieldNames, multiple, displayRender) => {
   return React.useMemo(() => {
-    const mergedDisplayRender = displayRender || ( // Default displayRender
+    const mergedDisplayRender = displayRender || (
+    // Default displayRender
     labels => {
       const mergedLabels = multiple ? labels.slice(-1) : labels;
       const SPLIT = ' / ';
-
       if (mergedLabels.every(label => ['string', 'number'].includes(typeof label))) {
         return mergedLabels.join(SPLIT);
-      } // If exist non-string value, use ReactNode instead
-
-
+      }
+      // If exist non-string value, use ReactNode instead
       return mergedLabels.reduce((list, label, index) => {
         const keyedLabel = React.isValidElement(label) ? React.cloneElement(label, {
           key: index
         }) : label;
-
         if (index === 0) {
           return [keyedLabel];
         }
-
         return [...list, SPLIT, keyedLabel];
       }, []);
     });
-
     return rawValues.map(valueCells => {
       var _a, _b;
-
       const valueOptions = toPathOptions(valueCells, options, fieldNames);
       const label = mergedDisplayRender(valueOptions.map(({
         option,
         value
       }) => {
         var _a;
-
         return (_a = option === null || option === void 0 ? void 0 : option[fieldNames.label]) !== null && _a !== void 0 ? _a : value;
       }), valueOptions.map(({
         option

package/es/tntd-cascader/rc-cascader/hooks/useEntities.js

@@ -3,7 +3,6 @@ import * as React from 'react';
 import { convertDataToEntities } from 'rc-tree/lib/utils/treeUtil';
 import { VALUE_SPLIT } from '../utils/commonUtil';
 /** Lazy parse options data into conduct-able info to avoid perf issue in single mode */
-
 export default ((options, fieldNames) => {
   const cacheRef = React.useRef({
     options: null,
@@ -19,14 +18,13 @@ export default ((options, fieldNames) => {
         }),
         processEntity: (entity, wrapper) => {
           const pathKey = entity.nodes.map(node => node[fieldNames.value]).join(VALUE_SPLIT);
-          wrapper.pathKeyEntities[pathKey] = entity; // Overwrite origin key.
+          wrapper.pathKeyEntities[pathKey] = entity;
+          // Overwrite origin key.
           // this is very hack but we need let conduct logic work with connect path
-
           entity.key = pathKey;
         }
       });
     }
-
     return cacheRef.current.info.pathKeyEntities;
   }, [fieldNames, options]);
   return getEntities;

package/es/tntd-cascader/rc-cascader/hooks/useMissingValues.js

@@ -6,7 +6,6 @@ export default ((options, fieldNames) => {
     const existsValues = [];
     rawValues.forEach(valueCell => {
       const pathOptions = toPathOptions(valueCell, options, fieldNames);
-
       if (pathOptions.every(opt => opt.option)) {
         existsValues.push(valueCell);
       } else {

package/es/tntd-cascader/rc-cascader/hooks/useRefFunc.js

@@ -4,7 +4,6 @@ import * as React from 'react';
  * Same as `React.useCallback` but always return a memoized function
  * but redirect to real function.
  */
-
 export default function useRefFunc(callback) {
   const funcRef = React.useRef();
   funcRef.current = callback;

package/es/tntd-cascader/rc-cascader/hooks/useSearchConfig.js

@@ -1,30 +1,25 @@
 // @ts-nocheck
 import * as React from 'react';
-import warning from 'rc-util/lib/warning'; // Convert `showSearch` to unique config
-
+import warning from 'rc-util/lib/warning';
+// Convert `showSearch` to unique config
 export default function useSearchConfig(showSearch) {
   return React.useMemo(() => {
     if (!showSearch) {
       return [false, {}];
     }
-
     let searchConfig = {
       matchInputWidth: true,
       limit: 50
     };
-
     if (showSearch && typeof showSearch === 'object') {
       searchConfig = Object.assign(Object.assign({}, searchConfig), showSearch);
     }
-
     if (searchConfig.limit <= 0) {
       delete searchConfig.limit;
-
       if (process.env.NODE_ENV !== 'production') {
         warning(false, "'limit' of showSearch should be positive number or false.");
       }
     }
-
     return [true, searchConfig];
   }, [showSearch]);
 }

package/es/tntd-cascader/rc-cascader/hooks/useSearchOptions.js

@@ -1,12 +1,9 @@
 import * as React from 'react';
 export const SEARCH_MARK = '__rc_cascader_search_mark__';
-
 const defaultFilter = (search, options, {
   label
 }) => options.some(opt => String(opt[label]).toLowerCase().includes(search.toLowerCase()));
-
 const defaultRender = (inputValue, path, prefixCls, fieldNames) => path.map(opt => opt[fieldNames.label]).join(' / ');
-
 export default ((search, options, fieldNames, prefixCls, config, changeOnSelect) => {
   const {
     filter = defaultFilter,
@@ -16,23 +13,22 @@ export default ((search, options, fieldNames, prefixCls, config, changeOnSelect)
   } = config;
   return React.useMemo(() => {
     const filteredOptions = [];
-
     if (!search) {
       return [];
     }
-
     function dig(list, pathOptions) {
       list.forEach(option => {
         // Perf saving when `sort` is disabled and `limit` is provided
         if (!sort && limit > 0 && filteredOptions.length >= limit) {
           return;
         }
-
         const connectedPathOptions = [...pathOptions, option];
-        const children = option[fieldNames.children]; // If current option is filterable
-
-        if ( // If is leaf option
-        !children || children.length === 0 || // If is changeOnSelect
+        const children = option[fieldNames.children];
+        // If current option is filterable
+        if (
+        // If is leaf option
+        !children || children.length === 0 ||
+        // If is changeOnSelect
         changeOnSelect) {
           if (filter(search, connectedPathOptions, {
             label: fieldNames.label
@@ -43,21 +39,18 @@ export default ((search, options, fieldNames, prefixCls, config, changeOnSelect)
             }));
           }
         }
-
         if (children) {
           dig(option[fieldNames.children], connectedPathOptions);
         }
       });
     }
-
-    dig(options, []); // Do sort
-
+    dig(options, []);
+    // Do sort
     if (sort) {
       filteredOptions.sort((a, b) => {
         return sort(a[SEARCH_MARK], b[SEARCH_MARK], search, fieldNames);
       });
     }
-
     return limit > 0 ? filteredOptions.slice(0, limit) : filteredOptions;
   }, [search, options, fieldNames, prefixCls, render, changeOnSelect, filter, sort, limit]);
 });