@chaoswise/ui 3.0.6 → 3.0.8

package/lib/CWCascader/rc-cascader/OptionList/useKeyboard.js

@@ -0,0 +1,172 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import { useBaseProps } from 'rc-select-cascader';
+import KeyCode from 'rc-util/lib/KeyCode';
+import * as React from 'react';
+import { SEARCH_MARK } from '../hooks/useSearchOptions';
+import { getFullPathKeys, toPathKey } from '../utils/commonUtil';
+export default (function (ref, options, fieldNames, activeValueCells, setActiveValueCells, onKeyBoardSelect) {
+  var _useBaseProps = useBaseProps(),
+    direction = _useBaseProps.direction,
+    searchValue = _useBaseProps.searchValue,
+    toggleOpen = _useBaseProps.toggleOpen,
+    open = _useBaseProps.open;
+  var rtl = direction === 'rtl';
+  var _React$useMemo = React.useMemo(function () {
+      var activeIndex = -1;
+      var currentOptions = options;
+      var mergedActiveIndexes = [];
+      var mergedActiveValueCells = [];
+      var len = activeValueCells.length;
+      var pathKeys = getFullPathKeys(options, fieldNames);
+      // Fill validate active value cells and index
+      var _loop = function _loop(i) {
+        // Mark the active index for current options
+        var nextActiveIndex = currentOptions.findIndex(function (option, index) {
+          return (pathKeys[index] ? toPathKey(pathKeys[index]) : option[fieldNames.value]) === activeValueCells[i];
+        });
+        if (nextActiveIndex === -1) {
+          return 1; // break
+        }
+        activeIndex = nextActiveIndex;
+        mergedActiveIndexes.push(activeIndex);
+        mergedActiveValueCells.push(activeValueCells[i]);
+        currentOptions = currentOptions[activeIndex][fieldNames.children];
+      };
+      for (var i = 0; i < len && currentOptions; i += 1) {
+        if (_loop(i)) break;
+      }
+      // Fill last active options
+      var activeOptions = options;
+      for (var _i = 0; _i < mergedActiveIndexes.length - 1; _i += 1) {
+        activeOptions = activeOptions[mergedActiveIndexes[_i]][fieldNames.children];
+      }
+      return [mergedActiveValueCells, activeIndex, activeOptions, pathKeys];
+    }, [activeValueCells, fieldNames, options]),
+    _React$useMemo2 = _slicedToArray(_React$useMemo, 4),
+    validActiveValueCells = _React$useMemo2[0],
+    lastActiveIndex = _React$useMemo2[1],
+    lastActiveOptions = _React$useMemo2[2],
+    fullPathKeys = _React$useMemo2[3];
+  // Update active value cells and scroll to target element
+  var internalSetActiveValueCells = function internalSetActiveValueCells(next) {
+    setActiveValueCells(next);
+  };
+  // Same options offset
+  var offsetActiveOption = function offsetActiveOption(offset) {
+    var len = lastActiveOptions.length;
+    var currentIndex = lastActiveIndex;
+    if (currentIndex === -1 && offset < 0) {
+      currentIndex = len;
+    }
+    for (var i = 0; i < len; i += 1) {
+      currentIndex = (currentIndex + offset + len) % len;
+      var option = lastActiveOptions[currentIndex];
+      if (option && !option.disabled) {
+        var nextActiveCells = validActiveValueCells.slice(0, -1).concat(fullPathKeys[currentIndex] ? toPathKey(fullPathKeys[currentIndex]) : option[fieldNames.value]);
+        internalSetActiveValueCells(nextActiveCells);
+        return;
+      }
+    }
+  };
+  // Different options offset
+  var prevColumn = function prevColumn() {
+    if (validActiveValueCells.length > 1) {
+      var nextActiveCells = validActiveValueCells.slice(0, -1);
+      internalSetActiveValueCells(nextActiveCells);
+    } else {
+      toggleOpen(false);
+    }
+  };
+  var nextColumn = function nextColumn() {
+    var _lastActiveOptions$la;
+    var nextOptions = ((_lastActiveOptions$la = lastActiveOptions[lastActiveIndex]) === null || _lastActiveOptions$la === void 0 ? void 0 : _lastActiveOptions$la[fieldNames.children]) || [];
+    var nextOption = nextOptions.find(function (option) {
+      return !option.disabled;
+    });
+    if (nextOption) {
+      var nextActiveCells = [].concat(_toConsumableArray(validActiveValueCells), [nextOption[fieldNames.value]]);
+      internalSetActiveValueCells(nextActiveCells);
+    }
+  };
+  React.useImperativeHandle(ref, function () {
+    return {
+      // scrollTo: treeRef.current?.scrollTo,
+      onKeyDown: function 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) {
+        //               nextColumn();
+        //           }
+        //           else {
+        //               prevColumn();
+        //           }
+        //           break;
+        //       }
+        //       case KeyCode.RIGHT: {
+        //           if (rtl) {
+        //               prevColumn();
+        //           }
+        //           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 originOptions = 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();
+        //           }
+        //       }
+        //   }
+      },
+      onKeyUp: function onKeyUp() {}
+    };
+  });
+});

package/lib/CWCascader/rc-cascader/context.js

@@ -0,0 +1,3 @@
+import * as React from 'react';
+var CascaderContext = /*#__PURE__*/React.createContext(null);
+export default CascaderContext;

package/lib/CWCascader/rc-cascader/hooks/useDisplayValues.js

@@ -0,0 +1,85 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import { toPathOptions } from "../utils/treeUtil";
+import * as React from "react";
+import { toPathKey } from "../utils/commonUtil";
+export default (function (rawValues, options, fieldNames, multiple, displayRender, labelInValueOption) {
+  return React.useMemo(function () {
+    var mergedDisplayRender = displayRender ||
+    // Default displayRender
+    function (labels) {
+      var mergedLabels = multiple ? labels.slice(-1) : labels;
+      var SPLIT = " / ";
+      if (mergedLabels.every(function (label) {
+        return ["string", "number"].includes(_typeof(label));
+      })) {
+        return mergedLabels.join(SPLIT);
+      }
+      // If exist non-string value, use ReactNode instead
+      return mergedLabels.reduce(function (list, label, index) {
+        var keyedLabel = /*#__PURE__*/React.isValidElement(label) ? /*#__PURE__*/React.cloneElement(label, {
+          key: index
+        }) : label;
+        if (index === 0) {
+          return [keyedLabel];
+        }
+        return [].concat(_toConsumableArray(list), [SPLIT, keyedLabel]);
+      }, []);
+    };
+    return rawValues.map(function (valueCells) {
+      var _valueOptions;
+      var valueOptions = toPathOptions(valueCells, options, fieldNames);
+      var isBackEndQuery = false;
+      if (valueOptions.length && (valueOptions[valueOptions.length - 1].index === -1 || valueOptions[valueOptions.length - 1].index === undefined)) {
+        var findItem = labelInValueOption.find(function (item) {
+          return item.value == valueCells;
+        });
+        if (findItem) {
+          isBackEndQuery = true;
+          valueOptions[valueOptions.length - 1].option = {
+            value: valueOptions[valueOptions.length - 1].value,
+            label: findItem.label
+          };
+        }
+      }
+      var label;
+      if (isBackEndQuery) {
+        label = mergedDisplayRender(valueOptions.map(function (_ref) {
+          var option = _ref.option,
+            value = _ref.value;
+          return option === null || option === void 0 ? void 0 : option[fieldNames.label];
+        }).filter(Boolean), valueOptions.map(function (_ref2) {
+          var option = _ref2.option,
+            value = _ref2.value;
+          return option !== null && option !== void 0 ? option : {
+            label: undefined,
+            value: value
+          };
+        }));
+      } else {
+        label = mergedDisplayRender(valueOptions.map(function (_ref3) {
+          var _option$fieldNames$la;
+          var option = _ref3.option,
+            value = _ref3.value;
+          return (_option$fieldNames$la = option === null || option === void 0 ? void 0 : option[fieldNames.label]) !== null && _option$fieldNames$la !== void 0 ? _option$fieldNames$la : value;
+        }), valueOptions.map(function (_ref4) {
+          var option = _ref4.option;
+          return option;
+        }));
+      }
+      var value = toPathKey(valueCells);
+      return {
+        label: label,
+        value: value,
+        key: value,
+        valueCells: valueCells,
+        disabled: (_valueOptions = valueOptions[valueOptions.length - 1]) === null || _valueOptions === void 0 || (_valueOptions = _valueOptions.option) === null || _valueOptions === void 0 ? void 0 : _valueOptions.disabled
+      };
+    });
+  }, [rawValues, options, fieldNames, displayRender, multiple, labelInValueOption]);
+});

package/lib/CWCascader/rc-cascader/hooks/useEntities.js

@@ -0,0 +1,40 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as React from 'react';
+import { convertDataToEntities } from 'rc-tree-cascader/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 (function (options, fieldNames) {
+  var cacheRef = React.useRef({
+    options: null,
+    info: null
+  });
+  var getEntities = React.useCallback(function () {
+    if (cacheRef.current.options !== options) {
+      cacheRef.current.options = options;
+      cacheRef.current.info = convertDataToEntities(options, {
+        fieldNames: fieldNames,
+        initWrapper: function initWrapper(wrapper) {
+          return _objectSpread(_objectSpread({}, wrapper), {}, {
+            pathKeyEntities: {}
+          });
+        },
+        processEntity: function processEntity(entity, wrapper) {
+          var pathKey = entity.nodes.map(function (node) {
+            return node[fieldNames.value];
+          }).join(VALUE_SPLIT);
+          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/lib/CWCascader/rc-cascader/hooks/useMissingValues.js

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { toPathOptions } from '../utils/treeUtil';
+export default (function (options, fieldNames) {
+  return React.useCallback(function (rawValues) {
+    var missingValues = [];
+    var existsValues = [];
+    rawValues.forEach(function (valueCell) {
+      var pathOptions = toPathOptions(valueCell, options, fieldNames);
+      if (pathOptions.every(function (opt) {
+        return opt.option;
+      })) {
+        existsValues.push(valueCell);
+      } else {
+        missingValues.push(valueCell);
+      }
+    });
+    return [existsValues, missingValues];
+  }, [options, fieldNames]);
+});

package/lib/CWCascader/rc-cascader/hooks/useRefFunc.js

@@ -0,0 +1,13 @@
+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) {
+  var funcRef = React.useRef();
+  funcRef.current = callback;
+  var cacheFn = React.useCallback(function () {
+    return funcRef.current.apply(funcRef, arguments);
+  }, []);
+  return cacheFn;
+}

package/lib/CWCascader/rc-cascader/hooks/useSearchConfig.js

@@ -0,0 +1,30 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import * as React from 'react';
+import warning from 'rc-util/lib/warning';
+// Convert `showSearch` to unique config
+export default function useSearchConfig(showSearch) {
+  return React.useMemo(function () {
+    if (!showSearch) {
+      return [false, {}];
+    }
+    var searchConfig = {
+      matchInputWidth: true,
+      limit: 50
+    };
+    if (showSearch && _typeof(showSearch) === 'object') {
+      searchConfig = _objectSpread(_objectSpread({}, 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/lib/CWCascader/rc-cascader/hooks/useSearchOptions.js

@@ -0,0 +1,73 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import * as React from 'react';
+export var SEARCH_MARK = '__rc_cascader_search_mark__';
+var defaultFilter = function defaultFilter(search, options, _ref) {
+  var label = _ref.label;
+  return options.some(function (opt) {
+    return String(opt[label]).toLowerCase().includes(search.toLowerCase());
+  });
+};
+var defaultRender = function defaultRender(inputValue, path, prefixCls, fieldNames) {
+  return path.map(function (opt) {
+    return opt[fieldNames.label];
+  }).join(' / ');
+};
+export default (function (search, options, fieldNames, prefixCls, config, changeOnSelect) {
+  var _config$filter = config.filter,
+    filter = _config$filter === void 0 ? defaultFilter : _config$filter,
+    _config$render = config.render,
+    render = _config$render === void 0 ? defaultRender : _config$render,
+    _config$limit = config.limit,
+    limit = _config$limit === void 0 ? 50 : _config$limit,
+    sort = config.sort;
+  return React.useMemo(function () {
+    var filteredOptions = [];
+    if (!search) {
+      return [];
+    }
+    function dig(list, pathOptions) {
+      list.forEach(function (option) {
+        // Perf saving when `sort` is disabled and `limit` is provided
+        if (!sort && limit > 0 && filteredOptions.length >= limit) {
+          return;
+        }
+        var connectedPathOptions = [].concat(_toConsumableArray(pathOptions), [option]);
+        var 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
+          })) {
+            filteredOptions.push(_objectSpread(_objectSpread({}, option), {}, _defineProperty(_defineProperty({}, fieldNames.label, render(search, connectedPathOptions, prefixCls, fieldNames)), SEARCH_MARK, connectedPathOptions)));
+          }
+        }
+        if (children) {
+          dig(option[fieldNames.children], connectedPathOptions);
+        }
+      });
+    }
+    dig(options, []);
+    // Do sort
+    if (sort) {
+      filteredOptions.sort(function (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]);
+});

package/lib/CWCascader/rc-cascader/index.js

@@ -0,0 +1,2 @@
+import Cascader from './Cascader';
+export default Cascader;

package/lib/CWCascader/rc-cascader/utils/commonUtil.js

@@ -0,0 +1,54 @@
+import { SEARCH_MARK } from '../hooks/useSearchOptions';
+export var VALUE_SPLIT = '__RC_CASCADER_SPLIT__';
+export var SHOW_PARENT = 'SHOW_PARENT';
+export var SHOW_CHILD = 'SHOW_CHILD';
+export function toPathKey(value) {
+  return value.join(VALUE_SPLIT);
+}
+export function toPathKeys(value) {
+  return value.map(toPathKey);
+}
+export function toPathValueStr(pathKey) {
+  return pathKey.split(VALUE_SPLIT);
+}
+export function fillFieldNames(fieldNames) {
+  var _ref = fieldNames || {},
+    label = _ref.label,
+    value = _ref.value,
+    children = _ref.children;
+  var val = value || 'value';
+  return {
+    label: label || 'label',
+    value: val,
+    key: val,
+    children: children || 'children'
+  };
+}
+export function isLeaf(option, fieldNames) {
+  var _option$isLeaf, _option$fieldNames$ch;
+  return (_option$isLeaf = option.isLeaf) !== null && _option$isLeaf !== void 0 ? _option$isLeaf : !((_option$fieldNames$ch = option[fieldNames.children]) !== null && _option$fieldNames$ch !== void 0 && _option$fieldNames$ch.length);
+}
+export function scrollIntoParentView(element) {
+  var parent = element.parentElement;
+  if (!parent) {
+    return;
+  }
+  var elementToParent = element.offsetTop - parent.offsetTop; // offsetParent may not be parent.
+  if (elementToParent - parent.scrollTop < 0) {
+    parent.scrollTo({
+      top: elementToParent
+    });
+  } else if (elementToParent + element.offsetHeight - parent.scrollTop > parent.offsetHeight) {
+    parent.scrollTo({
+      top: elementToParent + element.offsetHeight - parent.offsetHeight
+    });
+  }
+}
+export function getFullPathKeys(options, fieldNames) {
+  return options.map(function (item) {
+    var _item$SEARCH_MARK;
+    return (_item$SEARCH_MARK = item[SEARCH_MARK]) === null || _item$SEARCH_MARK === void 0 ? void 0 : _item$SEARCH_MARK.map(function (opt) {
+      return opt[fieldNames.value];
+    });
+  });
+}

package/lib/CWCascader/rc-cascader/utils/treeUtil.js

@@ -0,0 +1,81 @@
+import { SHOW_CHILD } from "./commonUtil";
+export function formatStrategyValues(pathKeys, getKeyPathEntities, showCheckedStrategy) {
+  var valueSet = new Set(pathKeys);
+  var keyPathEntities = getKeyPathEntities();
+  return pathKeys.filter(function (key) {
+    var entity = keyPathEntities[key];
+    var parent = entity ? entity.parent : null;
+    var children = entity ? entity.children : null;
+    return showCheckedStrategy === SHOW_CHILD ? !(children && children.some(function (child) {
+      return child.key && valueSet.has(child.key);
+    })) : !(parent && !parent.node.disabled && valueSet.has(parent.key));
+  });
+}
+export function toPathOptions(valueCells, options, fieldNames) {
+  var stringMode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var labelInValue = arguments.length > 4 ? arguments[4] : undefined;
+  var labelInValueOption = arguments.length > 5 ? arguments[5] : undefined;
+  var currentList = options;
+  var valueOptions = [];
+  var isHit = true;
+  var _loop = function _loop() {
+    var _currentList, _currentList2, _foundOption$fieldNam;
+    var valueCell = valueCells[i];
+    var foundIndex = (_currentList = currentList) === null || _currentList === void 0 ? void 0 : _currentList.findIndex(function (option) {
+      var val = option[fieldNames.value];
+      return stringMode ? String(val) === String(valueCell) : val === valueCell;
+    });
+    var foundOption = foundIndex !== -1 ? (_currentList2 = currentList) === null || _currentList2 === void 0 ? void 0 : _currentList2[foundIndex] : null;
+    if (foundIndex === -1) {
+      isHit = false;
+    }
+    valueOptions.push({
+      value: (_foundOption$fieldNam = foundOption === null || foundOption === void 0 ? void 0 : foundOption[fieldNames.value]) !== null && _foundOption$fieldNam !== void 0 ? _foundOption$fieldNam : valueCell,
+      index: foundIndex,
+      option: foundOption
+    });
+    currentList = foundOption === null || foundOption === void 0 ? void 0 : foundOption[fieldNames.children];
+  };
+  for (var i = 0; i < valueCells.length; i += 1) {
+    _loop();
+  }
+  if (!isHit && labelInValue) {
+    var findOption = labelInValueOption.find(function (item) {
+      return item.value === valueCells;
+    });
+    if (findOption) {
+      valueOptions = [{
+        option: {
+          value: findOption.value,
+          label: findOption.label,
+          backEndQuery: true
+        }
+      }];
+    }
+  }
+  return valueOptions;
+}
+export function toValueAndLabel(valueOptions) {
+  var triggerValues = [];
+  valueOptions.forEach(function (item) {
+    var isBackEndQuery = item.some(function (i) {
+      return i.backEndQuery;
+    });
+    if (isBackEndQuery) {
+      triggerValues.push({
+        label: item[0].label,
+        value: item[0].value
+      });
+    } else {
+      var value = [];
+      item.forEach(function (i) {
+        value.push(i.value);
+      });
+      triggerValues.push({
+        label: item[item.length - 1].label,
+        value: value
+      });
+    }
+  });
+  return triggerValues;
+}

package/lib/CWCascader/rc-cascader/utils/warningPropsUtil.js

@@ -0,0 +1,30 @@
+import warning from 'rc-util/lib/warning';
+function warningProps(props) {
+  var onPopupVisibleChange = props.onPopupVisibleChange,
+    popupVisible = props.popupVisible,
+    popupClassName = props.popupClassName,
+    popupPlacement = props.popupPlacement;
+  warning(!onPopupVisibleChange, '`onPopupVisibleChange` is deprecated. Please use `onDropdownVisibleChange` instead.');
+  warning(popupVisible === undefined, '`popupVisible` is deprecated. Please use `open` instead.');
+  warning(popupClassName === undefined, '`popupClassName` is deprecated. Please use `dropdownClassName` instead.');
+  warning(popupPlacement === undefined, '`popupPlacement` is deprecated. Please use `placement` instead.');
+}
+// value in Cascader options should not be null
+export function warningNullOptions(options, fieldNames) {
+  if (options) {
+    var recursiveOptions = function recursiveOptions(optionsList) {
+      for (var i = 0; i < optionsList.length; i++) {
+        var option = optionsList[i];
+        if (option[fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.value] === null) {
+          warning(false, '`value` in Cascader options should not be `null`.');
+          return true;
+        }
+        if (Array.isArray(option[fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.children]) && recursiveOptions(option[fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.children])) {
+          return true;
+        }
+      }
+    };
+    recursiveOptions(options);
+  }
+}
+export default warningProps;