one-design-next 0.0.4-alpha.57

package/dist/time-picker/style/index.css

@@ -0,0 +1,166 @@
+:root {
+  --odn-tp-input-padding-inline-end: 32px;
+  --odn-tp-input-padding-inline-start: 12px;
+  --odn-tp-input-padding-block: 6px;
+  --odn-tp-input-border-radius: 6px;
+  --odn-tp-input-width: 160px;
+  --odn-tp-input-height: 36px;
+  --odn-tp-input-font-size: 14px;
+  --odn-tp-input-line-height: 1.5;
+  --odn-tp-icon-size: 16px;
+  --odn-tp-icon-right: 8px;
+  --odn-tp-popup-padding-block: 8px;
+  --odn-tp-popup-padding-inline: 0;
+}
+
+[data-odn-time-picker-container] {
+  position: relative;
+  display: inline-block;
+  width: var(--odn-tp-input-width);
+}
+
+[data-odn-time-picker-container-disabled=true] [data-odn-time-picker-input] {
+  color: var(--odn-color-black-8);
+  background: var(--odn-color-black-3);
+  border: 1px solid var(--odn-color-black-6);
+  cursor: not-allowed;
+}
+[data-odn-time-picker-container-disabled=true] [data-odn-time-picker-icon-container] {
+  cursor: not-allowed;
+}
+[data-odn-time-picker-container-disabled=true] [data-odn-time-picker-icon] {
+  color: var(--odn-color-black-8);
+}
+
+[data-odn-time-picker-container-selected=true][data-odn-time-picker-container-disabled=false][data-odn-time-picker-container-allow-clear=true]:hover [data-odn-time-picker-icon-clear] {
+  opacity: 1;
+}
+[data-odn-time-picker-container-selected=true][data-odn-time-picker-container-disabled=false][data-odn-time-picker-container-allow-clear=true]:hover [data-odn-time-picker-icon-clock] {
+  opacity: 0;
+}
+
+[data-odn-time-picker-input] {
+  position: relative;
+  z-index: 1;
+  width: 100%;
+  min-height: 100%;
+  max-height: 100%;
+  font-family: inherit;
+  text-align: inherit;
+  font-size: var(--odn-tp-input-font-size);
+  line-height: var(--odn-tp-input-line-height);
+  color: #1f1f1f;
+  background-color: #fff;
+  border-radius: var(--odn-tp-input-border-radius);
+  outline: none;
+  appearance: none;
+  transition: 0.2s cubic-bezier(0.32, 0.72, 0, 1) background-color, 0.2s cubic-bezier(0.32, 0.72, 0, 1) border-color;
+  padding: var(--odn-tp-input-padding-block) var(--odn-tp-input-padding-inline-end) var(--odn-tp-input-padding-block) var(--odn-tp-input-padding-inline-start);
+  height: var(--odn-tp-input-height);
+  border: 1px solid var(--odn-color-black-6);
+}
+
+[data-odn-time-picker-input]:not([data-odn-time-picker-input-disabled=true]):hover {
+  border: 1px solid var(--odn-color-black-7);
+}
+[data-odn-time-picker-input]:not([data-odn-time-picker-input-disabled=true]):focus {
+  border: 1px solid var(--odn-color-primary);
+}
+
+[data-odn-time-picker-container-allow-clear=false] [data-odn-time-picker-icon-container],
+[data-odn-time-picker-container-selected=false] [data-odn-time-picker-icon-container] {
+  pointer-events: none;
+}
+
+[data-odn-time-picker-icon-container] {
+  position: absolute;
+  z-index: 1;
+  top: 50%;
+  right: var(--odn-tp-icon-right);
+  width: var(--odn-tp-icon-size);
+  height: var(--odn-tp-icon-size);
+  transform: translateY(-50%);
+  cursor: pointer;
+}
+
+[data-odn-time-picker-icon] {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 1;
+  transition: all 0.25s cubic-bezier(0.32, 0.72, 0, 1);
+}
+
+[data-odn-time-picker-icon-clock] {
+  color: var(--odn-color-black-9);
+}
+
+[data-odn-time-picker-icon-clear] {
+  opacity: 0;
+  color: var(--odn-color-black-7);
+}
+[data-odn-time-picker-icon-clear]:hover {
+  color: var(--odn-color-black-8);
+}
+[data-odn-time-picker-icon-clear]:active {
+  color: var(--odn-color-black-9);
+}
+
+[data-odn-time-picker-popup-content] {
+  display: flex;
+  height: calc(var(--odn-popup-control-height) * 6 + var(--odn-tp-popup-padding-block) * 2);
+  user-select: none;
+}
+
+[data-odn-time-picker-options] {
+  flex: 1;
+  padding: var(--odn-tp-popup-padding-block) var(--odn-tp-popup-padding-inline);
+  min-width: 80px;
+  display: flex;
+  flex-direction: column;
+  height: calc(var(--odn-popup-control-height) * 6 + var(--odn-tp-popup-padding-block) * 2);
+}
+[data-odn-time-picker-options]:not(:last-child) {
+  box-shadow: 1px 0 0 var(--odn-color-black-4);
+}
+
+[data-odn-time-picker-option] {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: var(--odn-popup-control-height);
+  font-size: 14px;
+  color: var(--odn-color-black-12);
+  cursor: pointer;
+  text-align: center;
+}
+[data-odn-time-picker-option]:hover:not([data-odn-time-picker-option-disabled=true]) {
+  background-color: var(--odn-color-black-1);
+}
+[data-odn-time-picker-option][data-odn-time-picker-option-selected=true] {
+  background-color: var(--odn-color-blue-1);
+}
+[data-odn-time-picker-option][data-odn-time-picker-option-selected=true]:hover {
+  background-color: var(--odn-color-blue-1);
+}
+
+[data-odn-time-picker-option-disabled=true] {
+  color: var(--odn-color-black-8);
+  cursor: not-allowed;
+}
+
+[data-odn-time-picker-padding-bottom] {
+  height: calc(var(--odn-popup-control-height) * 5);
+}
+
+[data-odn-time-picker-container-light=true] [data-odn-time-picker-input] {
+  background-color: transparent;
+  border: 1px solid transparent;
+}
+[data-odn-time-picker-container-light=true] [data-odn-time-picker-input]:hover {
+  border: 1px solid transparent;
+}
+[data-odn-time-picker-container-light=true] [data-odn-time-picker-input]:focus {
+  background-color: #fff;
+  border: 1px solid var(--odn-color-primary);
+}

package/dist/time-picker/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style';
+import './index.scss';

package/dist/time-picker/style/index.js

@@ -0,0 +1,2 @@
+import "../../style";
+import "./index.css";

package/dist/tooltip/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { PopoverProps } from '../pop-base';
+export interface TooltipGroupProps extends Omit<PopoverProps, 'popup'>, React.HTMLAttributes<JSX.IntrinsicElements> {
+    as?: keyof JSX.IntrinsicElements;
+}
+declare const Tooltip: React.FC<PopoverProps> & {
+    Group: typeof TooltipGroup;
+};
+declare const TooltipGroup: (props: TooltipGroupProps) => React.JSX.Element;
+export default Tooltip;

package/dist/tooltip/index.js

@@ -0,0 +1,178 @@
+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); }
+var _excluded = ["as", "arrowed", "autoPlacements", "offset", "popupStyle", "popupClassName", "mouseEnterDelay", "mouseLeaveDelay", "flip", "matchWidth", "portal", "shift", "children", "placement"],
+  _excluded2 = ["onMouseEnter", "onMouseLeave"];
+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(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import React, { useEffect, useRef, useState } from 'react';
+import PopBase from "../pop-base";
+var Tooltip = function Tooltip(props) {
+  return /*#__PURE__*/React.createElement(PopBase, _extends({
+    type: "tooltip",
+    mouseEnterDelay: 0.1
+  }, props));
+};
+var TooltipGroup = function TooltipGroup(props) {
+  var _tooltipInfos$hoverIn;
+  var _props$as = props.as,
+    as = _props$as === void 0 ? 'div' : _props$as,
+    arrowed = props.arrowed,
+    autoPlacements = props.autoPlacements,
+    offset = props.offset,
+    popupStyle = props.popupStyle,
+    popupClassName = props.popupClassName,
+    _props$mouseEnterDela = props.mouseEnterDelay,
+    mouseEnterDelay = _props$mouseEnterDela === void 0 ? 0.1 : _props$mouseEnterDela,
+    mouseLeaveDelay = props.mouseLeaveDelay,
+    flip = props.flip,
+    matchWidth = props.matchWidth,
+    portal = props.portal,
+    shift = props.shift,
+    children = props.children,
+    _props$placement = props.placement,
+    placement = _props$placement === void 0 ? 'top' : _props$placement,
+    otherProps = _objectWithoutProperties(props, _excluded);
+  var Tag = as;
+  var tooltipInfos = React.Children.toArray(children).map(function (child) {
+    if ( /*#__PURE__*/React.isValidElement(child)) {
+      return {
+        popup: child.props.popup,
+        children: child.props.children
+      };
+    }
+  }).filter(Boolean);
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    visible = _useState2[0],
+    setVisible = _useState2[1];
+  var _useState3 = useState(0),
+    _useState4 = _slicedToArray(_useState3, 2),
+    hoverIndex = _useState4[0],
+    setHoverIndex = _useState4[1];
+  var lastHoverIndex = useRef(hoverIndex);
+  var hoverTimer = useRef(0);
+  var tagRef = useRef(null);
+  var handleMouseEnter = function handleMouseEnter(e, index) {
+    clearTimeout(hoverTimer.current);
+    var currentTarget = e.currentTarget;
+    hoverTimer.current = window.setTimeout(function () {
+      var _tagRef$current;
+      setHoverIndex(index);
+      setVisible(true);
+      var _ref = ((_tagRef$current = tagRef.current) === null || _tagRef$current === void 0 ? void 0 : _tagRef$current.getBoundingClientRect()) || {
+          left: 0,
+          top: 0,
+          width: 0,
+          height: 0
+        },
+        left = _ref.left,
+        top = _ref.top,
+        width = _ref.width,
+        height = _ref.height;
+      var _currentTarget$getBou = currentTarget.getBoundingClientRect(),
+        targetLeft = _currentTarget$getBou.left,
+        targetTop = _currentTarget$getBou.top,
+        targetWidth = _currentTarget$getBou.width,
+        targetHeight = _currentTarget$getBou.height;
+      var offsetX = 0;
+      var offsetY = 0;
+      if (placement.startsWith('top') || placement.startsWith('bottom')) {
+        offsetX = targetLeft - left - width / 2 + targetWidth / 2;
+        if (placement.startsWith('top')) {
+          offsetY = targetTop - top;
+        } else {
+          offsetY = targetTop - top - height + targetHeight;
+        }
+      } else if (placement.startsWith('left') || placement.startsWith('right')) {
+        offsetY = targetTop - top - height / 2 + targetHeight / 2;
+        if (placement.startsWith('left')) {
+          offsetX = targetLeft - left;
+        } else {
+          offsetX = targetLeft - left - width + targetWidth;
+        }
+      }
+      setOffsetX(offsetX);
+      setOffsetY(offsetY);
+    }, visible ? 0 : mouseEnterDelay * 1000);
+  };
+  var handleMouseLeave = function handleMouseLeave(e, index) {
+    clearTimeout(hoverTimer.current);
+    hoverTimer.current = window.setTimeout(function () {
+      setVisible(false);
+    }, 200);
+  };
+  var _useState5 = useState(0),
+    _useState6 = _slicedToArray(_useState5, 2),
+    offsetX = _useState6[0],
+    setOffsetX = _useState6[1];
+  var _useState7 = useState(0),
+    _useState8 = _slicedToArray(_useState7, 2),
+    offsetY = _useState8[0],
+    setOffsetY = _useState8[1];
+  useEffect(function () {
+    if (lastHoverIndex.current !== hoverIndex) {
+      lastHoverIndex.current = hoverIndex;
+    }
+  }, [hoverIndex]);
+  useEffect(function () {
+    return function () {
+      clearTimeout(hoverTimer.current);
+    };
+  }, []);
+  return /*#__PURE__*/React.createElement(Tooltip, {
+    popup: /*#__PURE__*/React.createElement("div", {
+      "data-odn-tooltip-group-content": true
+    }, (_tooltipInfos$hoverIn = tooltipInfos[hoverIndex]) === null || _tooltipInfos$hoverIn === void 0 ? void 0 : _tooltipInfos$hoverIn.popup),
+    popupClassName: popupClassName,
+    autoPlacements: autoPlacements,
+    arrowed: arrowed,
+    offset: offset,
+    mouseEnterDelay: mouseEnterDelay,
+    mouseLeaveDelay: mouseLeaveDelay,
+    flip: flip,
+    matchWidth: matchWidth,
+    portal: portal,
+    shift: shift,
+    placement: placement,
+    visible: visible,
+    popupStyle: _objectSpread(_objectSpread({}, popupStyle), {}, {
+      transform: "translate(".concat(offsetX, "px, ").concat(offsetY, "px) scale(").concat(visible ? 1 : 0.8, ")")
+    })
+  }, /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Tag, _objectSpread({
+    ref: tagRef,
+    children: tooltipInfos.map(function (info, index) {
+      if ( /*#__PURE__*/React.isValidElement(info.children)) {
+        var _ref2 = info.children.props,
+          _onMouseEnter = _ref2.onMouseEnter,
+          _onMouseLeave = _ref2.onMouseLeave,
+          rest = _objectWithoutProperties(_ref2, _excluded2);
+        return /*#__PURE__*/React.cloneElement(info.children, _objectSpread(_objectSpread({
+          key: index
+        }, rest), {}, {
+          onMouseEnter: function onMouseEnter(e) {
+            handleMouseEnter(e, index);
+            _onMouseEnter === null || _onMouseEnter === void 0 || _onMouseEnter(e);
+          },
+          onMouseLeave: function onMouseLeave(e) {
+            handleMouseLeave(e, index);
+            _onMouseLeave === null || _onMouseLeave === void 0 || _onMouseLeave(e);
+          }
+        }));
+      }
+    })
+  }, otherProps))));
+};
+Tooltip.Group = TooltipGroup;
+Tooltip.displayName = 'Tooltip';
+export default Tooltip;

package/dist/tree-select/index.d.ts

@@ -0,0 +1,25 @@
+import type { TreeSelectProps as RcTreeSelectProps } from 'rc-tree-select';
+import React from 'react';
+import '../select/style';
+import './style';
+export interface TreeNodeData {
+    key: string | number;
+    title: React.ReactNode;
+    value: string | number;
+    children?: TreeNodeData[];
+    disabled?: boolean;
+    checkable?: boolean;
+    selectable?: boolean;
+    isLeaf?: boolean;
+}
+export interface TreeSelectProps extends Omit<RcTreeSelectProps, 'treeData'> {
+    treeData?: TreeNodeData[];
+    mode?: 'multiple';
+    visible?: RcTreeSelectProps['open'];
+    onVisibleChange?: RcTreeSelectProps['onDropdownVisibleChange'];
+    showInnerSearch?: boolean;
+    light?: boolean;
+    popupRender?: (menu: React.ReactElement) => React.ReactElement;
+}
+declare const TreeSelect: React.FC<TreeSelectProps>;
+export default TreeSelect;

package/dist/tree-select/index.js

@@ -0,0 +1,140 @@
+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); }
+var _excluded = ["mode", "suffixIcon", "visible", "onVisibleChange", "treeCheckable", "className", "showInnerSearch", "light", "popupRender", "searchValue", "onSearch"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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(arr) { if (Array.isArray(arr)) return arr; }
+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(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import clsx from 'clsx';
+import RcTreeSelect from 'rc-tree-select';
+import React, { useEffect, useRef, useState } from 'react';
+import Icon from "../icon";
+import "../select/style";
+import useIcons from "../select/useIcons";
+import "./style";
+var TreeSelect = function TreeSelect(_ref) {
+  var mode = _ref.mode,
+    _ref$suffixIcon = _ref.suffixIcon,
+    suffixIconProp = _ref$suffixIcon === void 0 ? /*#__PURE__*/React.createElement(Icon, {
+      name: "down"
+    }) : _ref$suffixIcon,
+    visibleProp = _ref.visible,
+    onVisibleChange = _ref.onVisibleChange,
+    _ref$treeCheckable = _ref.treeCheckable,
+    treeCheckable = _ref$treeCheckable === void 0 ? true : _ref$treeCheckable,
+    className = _ref.className,
+    _ref$showInnerSearch = _ref.showInnerSearch,
+    showInnerSearch = _ref$showInnerSearch === void 0 ? false : _ref$showInnerSearch,
+    _ref$light = _ref.light,
+    light = _ref$light === void 0 ? false : _ref$light,
+    popupRender = _ref.popupRender,
+    searchValueProp = _ref.searchValue,
+    onSearch = _ref.onSearch,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  var isMultiple = mode === 'multiple';
+  var _useIcons = useIcons(_objectSpread(_objectSpread({}, rest), {}, {
+      multiple: isMultiple,
+      hasFeedback: false,
+      feedbackIcon: undefined,
+      showSuffixIcon: !!suffixIconProp,
+      prefixCls: 'odn-select',
+      suffixIcon: suffixIconProp
+    })),
+    _suffixIcon = _useIcons.suffixIcon,
+    itemIcon = _useIcons.itemIcon,
+    removeIcon = _useIcons.removeIcon,
+    clearIcon = _useIcons.clearIcon;
+  var _useState = useState(visibleProp),
+    _useState2 = _slicedToArray(_useState, 2),
+    visible = _useState2[0],
+    setVisible = _useState2[1];
+  var _useState3 = useState(searchValueProp || ''),
+    _useState4 = _slicedToArray(_useState3, 2),
+    searchValue = _useState4[0],
+    setSearchValue = _useState4[1];
+  var dropdownSearchInputRef = useRef(null);
+  var handleVisibleChange = function handleVisibleChange(bool) {
+    if (visibleProp === undefined) {
+      setVisible(bool);
+    }
+    onVisibleChange === null || onVisibleChange === void 0 || onVisibleChange(bool);
+  };
+  useEffect(function () {
+    if (searchValueProp !== undefined) {
+      setSearchValue(searchValueProp);
+    }
+  }, [searchValueProp]);
+  useEffect(function () {
+    if (visible) {
+      setTimeout(function () {
+        var _dropdownSearchInputR;
+        (_dropdownSearchInputR = dropdownSearchInputRef.current) === null || _dropdownSearchInputR === void 0 || _dropdownSearchInputR.focus();
+      }, 150);
+    }
+  }, [visible]);
+  return /*#__PURE__*/React.createElement(RcTreeSelect, _extends({
+    prefixCls: "odn-select",
+    dropdownClassName: clsx('odn-ts', isMultiple && 'odn-ts-multiple'),
+    className: clsx(className, showInnerSearch && 'odn-select-show-inner-search', light && 'odn-select-light', !light && 'odn-select-outlined'),
+    transitionName: "odn-slide-up",
+    showSearch: false,
+    suffixIcon: function suffixIcon(suffixIconProps) {
+      var suffixIconFinal = typeof _suffixIcon === 'function' ? _suffixIcon(suffixIconProps) : _suffixIcon;
+      return /*#__PURE__*/React.createElement(React.Fragment, null, suffixIconFinal);
+    },
+    switcherIcon: /*#__PURE__*/React.createElement(Icon, {
+      name: "right"
+    }),
+    removeIcon: removeIcon,
+    clearIcon: clearIcon,
+    open: visible,
+    onDropdownVisibleChange: handleVisibleChange,
+    multiple: isMultiple,
+    treeCheckable: isMultiple ? treeCheckable ? /*#__PURE__*/React.createElement("span", {
+      className: "odn-select-tree-checkbox-inner"
+    }) : treeCheckable : false,
+    showCheckedStrategy: "SHOW_PARENT",
+    searchValue: searchValue,
+    dropdownRender: function dropdownRender(menu) {
+      var searchNode = showInnerSearch ? /*#__PURE__*/React.createElement("div", {
+        className: "odn-select-dropdown-top"
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "odn-select-dropdown-search"
+      }, /*#__PURE__*/React.createElement(Icon, {
+        name: "search",
+        className: "odn-select-dropdown-search-icon"
+      }), /*#__PURE__*/React.createElement("input", {
+        ref: dropdownSearchInputRef,
+        className: "odn-select-dropdown-search-input",
+        placeholder: "\u8BF7\u8F93\u5165",
+        value: searchValue,
+        onChange: function onChange(e) {
+          var value = e.target.value;
+          if (searchValueProp === undefined) {
+            setSearchValue(value);
+          }
+          if (onSearch) {
+            onSearch(value);
+          }
+        },
+        onKeyDown: function onKeyDown(e) {
+          e.stopPropagation();
+        }
+      }))) : null;
+      var content = /*#__PURE__*/React.createElement(React.Fragment, null, searchNode, menu);
+      return popupRender ? popupRender(content) : content;
+    },
+    notFoundContent: "\u65E0\u5339\u914D\u7ED3\u679C"
+  }, rest));
+};
+TreeSelect.displayName = 'TreeSelect';
+export default TreeSelect;