@infomaximum/ui-kit 0.12.12 → 0.13.1

package/dist/components/TreeSelect/TreeSelect.tokens.js

@@ -0,0 +1,31 @@
+const getTreeSelectTokens = (theme) => ({
+  treeSelectBorder: theme.lineBorder,
+  treeSelectBorderHover: theme.primaryHover,
+  treeSelectBorderActive: theme.primaryBase,
+  treeSelectBorderDanger: theme.dangerBase,
+  treeSelectBorderDangerHover: theme.dangerHover,
+  treeSelectBg: theme.bgContainer,
+  treeSelectBgDisabled: theme.bgContainerDisabled,
+  treeSelectPlaceholder: theme.textHint,
+  treeSelectText: theme.textPrimary,
+  treeSelectTextDisabled: theme.textDisabled,
+  treeSelectTextDanger: theme.dangerBase,
+  treeSelectMultipleItemBorder: theme.tagNeutralBorder,
+  treeSelectMultipleItemBg: theme.tagNeutralBg,
+  treeSelectMultipleItemBgDisabled: theme.bgContainerDisabledContrast,
+  treeSelectOptionText: theme.textPrimary,
+  treeSelectOptionTextSelected: theme.primaryBase,
+  treeSelectOptionTextDisabled: theme.textDisabled,
+  treeSelectOptionBgHover: theme.bgContainerHover,
+  treeSelectPaddingVertical: theme.x1,
+  treeSelectPaddingHorizontal: theme.x3,
+  treeSelectPaddingHorizontalTag: theme.x1,
+  treeSelectOptionPaddingVertical: theme.x1,
+  treeSelectOptionPaddingHorizontal: theme.x2,
+  treeSelectSwitcherPadding: theme.x2,
+  treeSelectNodeGap: theme.x05,
+  treeSelectNodeIndent: 24
+});
+export {
+  getTreeSelectTokens
+};

package/dist/components/TreeSelect/TreeSelect.types.d.ts

@@ -0,0 +1,69 @@
+import { BaseOptionValue, BaseSelectStyles, ModeType, PlacementType, SelectStatus, VariantType } from 'components/BaseSelect/BaseSelect.types';
+import { TreeSelectNodeStyles, TreeNode } from './components/TreeSelectOption/TreeSelectOption.types';
+import { ReactNode, UIEvent } from 'react';
+export type ShowCheckedStrategyType = "child" | "parent" | "all";
+export type TreeSelectNodeValue = BaseOptionValue;
+export interface TreeSelectStyles {
+    baseSelectStyles?: BaseSelectStyles;
+    nodeStyles?: TreeSelectNodeStyles;
+}
+export interface TreeSelectProps {
+    allowClear?: boolean;
+    autoClearSearchValue?: boolean;
+    autoFocus?: boolean;
+    defaultOpen?: boolean;
+    defaultValue?: string | string[];
+    disabled?: boolean;
+    dropdownClassName?: string;
+    dropdownMatchSelectWidth?: boolean | number;
+    dropdownRender?: (originNode: ReactNode) => ReactNode;
+    dropdownMaxHeight?: number;
+    dropdownMinWidth?: number;
+    getPopupContainer?: () => HTMLElement;
+    loading?: boolean;
+    maxTagCount?: number | "responsive";
+    maxTagPlaceholder?: ((omittedValues: TreeNode[]) => ReactNode) | ReactNode;
+    maxTagTextLength?: number;
+    mode?: ModeType;
+    notFoundContent?: ReactNode;
+    emptyContent?: ReactNode;
+    open?: boolean;
+    placeholder?: ReactNode;
+    placement?: PlacementType;
+    prefix?: ReactNode;
+    searchValue?: string;
+    showSearch?: boolean;
+    status?: SelectStatus;
+    suffixIcon?: ReactNode;
+    value?: string | string[];
+    variant?: VariantType;
+    virtual?: boolean;
+    styles?: TreeSelectStyles;
+    onChange?: (value: string[], treeNode: TreeNode[]) => void;
+    onSearch?: (searchValue: string) => void;
+    onDropdownVisibleChange?: () => void;
+    onSelect?: (value: string, node: TreeNode) => void;
+    onDeselect?: (nodeKey: string) => void;
+    onPopupScroll?: (event: UIEvent) => void;
+    filterTreeNode?: boolean | ((inputValue: string, treeNode: TreeNode) => boolean);
+    showCheckedStrategy?: ShowCheckedStrategyType;
+    treeCheckable?: boolean;
+    treeData?: TreeNode[];
+    treeDefaultExpandAll?: boolean;
+    treeDefaultExpandedKeys?: string[];
+    treeExpandedKeys?: string[];
+    treeLoadedKeys?: string[];
+    treeNodeFilterProp?: string;
+    treeNodeLabelProp?: string;
+    onTreeExpand?: (expandedKeys: string[]) => void;
+    onExpandSwitcherClick?: (nodeKey: string) => void;
+    loadData?: (node: TreeNode) => Promise<TreeNode[]>;
+}
+export interface NodeData {
+    key: string;
+    isLeafNode: boolean;
+    parentKey: string;
+    childrenKeys: string[];
+    leafChildrenKeys: string[];
+    parentKeys: string[];
+}

package/dist/components/TreeSelect/TreeSelect.utils.d.ts

@@ -0,0 +1,13 @@
+import { TreeNode } from './components/TreeSelectOption/TreeSelectOption.types';
+import { NodeData, TreeSelectNodeValue } from './TreeSelect.types';
+export declare const ROOT_NODE = "ROOT_NODE";
+export declare const filterItems: (items: TreeNode[], searchValue: string, treeNodeFilterProp: string) => TreeNode[];
+export declare const isSelectedByChildStrategy: (treeNode: TreeNode, currentValue: TreeSelectNodeValue[], isLastNoe: boolean) => boolean;
+export declare const isSelectedByParentAndAllStrategy: (treeNodes: TreeNode, currentValue: TreeSelectNodeValue[]) => boolean;
+export declare const getNodeData: (treeNode: TreeNode, parentKey: string, parentKeys: string[], dataMap: Map<string, NodeData>, treeNodeMap: Map<string, TreeNode>) => NodeData;
+export declare const getAddedParentKeys: (parentKey: string, childNodeData: NodeData, nodeDataMap: Map<string, NodeData>, currentValue: TreeSelectNodeValue[]) => string[];
+export declare const getAllParentKeys: (treeData: TreeNode[]) => string[];
+export declare const addChildrenNodesToTree: (treeData: TreeNode[], nodeChildren: TreeNode[], nodeKey: string, nodeDataMap: Map<string, NodeData>) => TreeNode[] | undefined;
+export declare const flattenedNodes: (nodes: TreeNode[], expandedKeys: string[]) => string[];
+export declare const getNextOption: (currentIndex: number, flattenedTreeDataKeys: string[], treeNodeMap: Map<string, TreeNode>, isDecrement?: boolean) => number | null;
+export declare const getDefaultKeysByDefaultValues: (defaultValue: string | string[] | undefined, treeData: TreeNode[]) => string[];

package/dist/components/TreeSelect/TreeSelect.utils.js

@@ -0,0 +1,192 @@
+import { isKeyOfObject } from "../BaseSelect/BaseSelect.utils.js";
+import { isNull, isUndefined, isString } from "lodash-es";
+const ROOT_NODE = "ROOT_NODE";
+const checkNode = (treeNode, inputValue, treeNodeFilterProp) => {
+  var _a;
+  const {
+    children
+  } = treeNode;
+  const nodeFilterValue = isKeyOfObject(treeNode, treeNodeFilterProp) ? ((_a = treeNode[treeNodeFilterProp]) == null ? void 0 : _a.toString().toLowerCase()) ?? "" : "";
+  const hasIncluded = nodeFilterValue.includes(inputValue);
+  const withoutChildren = !children || children.length === 0;
+  if (hasIncluded) {
+    return treeNode;
+  }
+  if (withoutChildren) {
+    return null;
+  }
+  const filteredChildren = filterItems(children, inputValue, treeNodeFilterProp);
+  if (filteredChildren.length === 0) {
+    return null;
+  }
+  return {
+    ...treeNode,
+    children: filteredChildren
+  };
+};
+const filterItems = (items, searchValue, treeNodeFilterProp) => {
+  const filteredItems = items.map((item) => checkNode(item, searchValue, treeNodeFilterProp));
+  return filteredItems.filter((item) => !isNull(item));
+};
+const isSelectedByChildStrategy = (treeNode, currentValue, isLastNoe) => {
+  const {
+    children,
+    key
+  } = treeNode;
+  if (!isLastNoe && children) {
+    return children.every((child) => isSelectedByChildStrategy(child, currentValue, isLastNoe));
+  }
+  return currentValue.includes(key);
+};
+const isSelectedByParentAndAllStrategy = (treeNodes, currentValue) => {
+  const {
+    key
+  } = treeNodes;
+  return currentValue.includes(key);
+};
+const getNodeData = (treeNode, parentKey, parentKeys, dataMap, treeNodeMap) => {
+  const {
+    leaf,
+    children,
+    key
+  } = treeNode;
+  treeNodeMap.set(treeNode.key, treeNode);
+  const isLeafNode = leaf || !children || (children == null ? void 0 : children.length) === 0;
+  const baseNodeData = {
+    key,
+    isLeafNode,
+    parentKey,
+    parentKeys: parentKey === ROOT_NODE ? parentKeys : [...parentKeys, parentKey],
+    childrenKeys: [],
+    leafChildrenKeys: []
+  };
+  if (isLeafNode) {
+    dataMap.set(key, baseNodeData);
+    return baseNodeData;
+  }
+  const nodeData = children.reduce((acc, child) => {
+    const childData = getNodeData(child, key, acc.parentKeys, dataMap, treeNodeMap);
+    const childrenKeys = [...acc.childrenKeys, childData.key, ...childData.childrenKeys];
+    const leafChildrenKeys = childData.isLeafNode ? [...acc.leafChildrenKeys, childData.key] : [...acc.leafChildrenKeys, ...childData.leafChildrenKeys];
+    return {
+      ...acc,
+      childrenKeys,
+      leafChildrenKeys
+    };
+  }, baseNodeData);
+  dataMap.set(key, nodeData);
+  return nodeData;
+};
+const getAddedParentKeys = (parentKey, childNodeData, nodeDataMap, currentValue) => {
+  const parentNodeData = nodeDataMap.get(parentKey);
+  if (!parentNodeData) {
+    return [];
+  }
+  const selected = parentNodeData.childrenKeys.every((key) => currentValue.includes(key) || childNodeData.childrenKeys.includes(key) || key === childNodeData.key);
+  if (!selected) {
+    return [];
+  }
+  return [parentKey, ...getAddedParentKeys(parentNodeData.parentKey, parentNodeData, nodeDataMap, currentValue)];
+};
+const getAllParentKeys = (treeData) => {
+  return treeData.reduce((acc, node) => {
+    const {
+      children
+    } = node;
+    if (!children || children.length === 0) {
+      return acc;
+    }
+    const childrenKeys = getAllParentKeys(children);
+    return [...acc, node.key, ...childrenKeys];
+  }, []);
+};
+const addChildrenByPath = (treeData, path, newChildrenNodes) => {
+  const [currentKey, ...otherKeys] = path;
+  const currentNodeIndex = treeData.findIndex((node) => node.key === currentKey);
+  const currentNode = treeData[currentNodeIndex];
+  let newNode;
+  if (otherKeys.length > 0 && currentNode.children) {
+    const children = addChildrenByPath(currentNode.children, otherKeys, newChildrenNodes);
+    newNode = {
+      ...currentNode,
+      children
+    };
+  } else {
+    newNode = {
+      ...currentNode,
+      children: newChildrenNodes
+    };
+  }
+  const newTreeData = [...treeData];
+  newTreeData.splice(currentNodeIndex, 1, newNode);
+  return newTreeData;
+};
+const addChildrenNodesToTree = (treeData, nodeChildren, nodeKey, nodeDataMap) => {
+  const nodeData = nodeDataMap.get(nodeKey);
+  if (!nodeData) {
+    return;
+  }
+  const pathToNode = [...nodeData.parentKeys, nodeKey];
+  return addChildrenByPath(treeData, pathToNode, nodeChildren);
+};
+const flattenedNodes = (nodes, expandedKeys) => {
+  return nodes.reduce((acc, node) => {
+    if (!expandedKeys.includes(node.key)) {
+      return [...acc, node.key];
+    }
+    const childrenNodes = flattenedNodes(node.children ?? [], expandedKeys);
+    return [...acc, node.key, ...childrenNodes];
+  }, []);
+};
+const getNextOption = (currentIndex, flattenedTreeDataKeys, treeNodeMap, isDecrement = false) => {
+  const nextIndex = isDecrement ? currentIndex - 1 : currentIndex + 1;
+  if (nextIndex < 0 || nextIndex >= flattenedTreeDataKeys.length) {
+    return null;
+  }
+  const nextNodeKey = flattenedTreeDataKeys[nextIndex];
+  const nextNode = treeNodeMap.get(nextNodeKey);
+  if (!nextNode) {
+    return null;
+  }
+  if (nextNode.disabled) {
+    return getNextOption(nextIndex, flattenedTreeDataKeys, treeNodeMap, isDecrement);
+  }
+  return nextIndex;
+};
+const isDefaultNode = (defaultValue, nodeValue) => {
+  if (isString(defaultValue)) {
+    return nodeValue === defaultValue;
+  }
+  return defaultValue.includes(nodeValue);
+};
+const getDefaultKeysByDefaultValues = (defaultValue, treeData) => {
+  if (isUndefined(defaultValue)) {
+    return [];
+  }
+  return treeData.reduce((acc, node) => {
+    if (isUndefined(node.children)) {
+      if (isDefaultNode(defaultValue, node.value)) {
+        return [...acc, node.key];
+      }
+      return acc;
+    }
+    const defaultChildrenNodes = getDefaultKeysByDefaultValues(defaultValue, node.children);
+    if (isDefaultNode(defaultValue, node.value)) {
+      return [...acc, node.key, ...defaultChildrenNodes];
+    }
+    return [...acc, ...defaultChildrenNodes];
+  }, []);
+};
+export {
+  ROOT_NODE,
+  addChildrenNodesToTree,
+  filterItems,
+  flattenedNodes,
+  getAddedParentKeys,
+  getAllParentKeys,
+  getDefaultKeysByDefaultValues,
+  getNextOption,
+  getNodeData,
+  isSelectedByChildStrategy,
+  isSelectedByParentAndAllStrategy
+};

package/dist/components/TreeSelect/components/TreeSelectOption/TreeSelectOption.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { TreeSelectOptionProps } from './TreeSelectOption.types';
+export declare const TreeSelectOption: FC<TreeSelectOptionProps>;

package/dist/components/TreeSelect/components/TreeSelectOption/TreeSelectOption.js

@@ -0,0 +1,117 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import { createElement } from "@emotion/react";
+import { useBaseSelectContext } from "../../../BaseSelect/contexts/BaseSelectContext.js";
+import { memo, useContext, useMemo, useRef } from "react";
+import { CheckOutlined, CaretDownOutlined, CaretRightOutlined } from "@infomaximum/icons";
+import { Checkbox } from "../../../Checkbox/index.js";
+import { getTreeSelectOptionStyle } from "./TreeSelectOption.styles.js";
+import { treeSelectContext } from "../../contexts/treeSelectContext.js";
+import { useResizeObserver } from "../../../../hooks/useResizeObserver.js";
+import { useTheme } from "../../../../hooks/useTheme/useTheme.js";
+import { LoadingOutlined } from "../../../../icons/icons/LoadingOutlined.js";
+const TreeSelectOption = memo((props) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const {
+    title,
+    icon,
+    leaf,
+    children,
+    disabled,
+    index,
+    itemKey: key,
+    styles
+  } = props;
+  const theme = useTheme();
+  const {
+    currentValue,
+    mode,
+    removeValue,
+    setValue,
+    closeOptionList
+  } = useBaseSelectContext();
+  const {
+    treeCheckable,
+    nodeDataMap,
+    expandedKeys,
+    isAsyncLoading,
+    loadingKeys,
+    onSwitcherClick,
+    changeElementSize,
+    getCurrentSelectingKey,
+    onCheckableClick
+  } = useContext(treeSelectContext);
+  const isOpen = useMemo(() => expandedKeys.includes(key), [expandedKeys, key]);
+  const elementRef = useRef(null);
+  const isSelecting = getCurrentSelectingKey() === key;
+  const selected = currentValue.includes(key);
+  const loading = loadingKeys.includes(key);
+  const isLastNode = leaf || !children || (children == null ? void 0 : children.length) === 0 && !isAsyncLoading;
+  const parentsCounter = ((_a = nodeDataMap.get(key)) == null ? void 0 : _a.parentKeys.length) ?? 0;
+  const isIndeterminate = !selected && ((_b = nodeDataMap.get(key)) == null ? void 0 : _b.childrenKeys.some((key2) => currentValue.includes(key2)));
+  useResizeObserver(elementRef, (entries) => {
+    if (parentsCounter > 0) {
+      return;
+    }
+    const entry = entries[0];
+    changeElementSize(index, entry.contentRect.height);
+  });
+  const handleClick = () => {
+    if (disabled) {
+      return;
+    }
+    if (treeCheckable) {
+      onCheckableClick(key);
+      return;
+    }
+    if (mode === "multiple") {
+      if (selected) {
+        removeValue(key);
+      } else {
+        setValue(key);
+      }
+      return;
+    }
+    setValue(key);
+    closeOptionList();
+  };
+  const getSwitcherIcon = () => {
+    if (loading) {
+      return /* @__PURE__ */ jsx(LoadingOutlined, {});
+    }
+    if (isOpen) {
+      return /* @__PURE__ */ jsx(CaretDownOutlined, {});
+    }
+    return /* @__PURE__ */ jsx(CaretRightOutlined, {});
+  };
+  const handleSwitcherClick = () => {
+    if (loading) {
+      return;
+    }
+    onSwitcherClick(key);
+  };
+  const treeSelectOptionStyle = getTreeSelectOptionStyle({
+    disabled: !!disabled,
+    loading: !!loading,
+    selected,
+    isSelecting,
+    treeCheckable,
+    isLastNode
+  });
+  return /* @__PURE__ */ jsxs("div", { ref: elementRef, css: [treeSelectOptionStyle.wrapper(), (_c = styles == null ? void 0 : styles.wrapper) == null ? void 0 : _c.call(styles), process.env.NODE_ENV === "production" ? "" : ";label:TreeSelectOption;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], children: [
+    /* @__PURE__ */ jsxs("div", { css: [treeSelectOptionStyle.header(theme), (_d = styles == null ? void 0 : styles.header) == null ? void 0 : _d.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:TreeSelectOption;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], title: title == null ? void 0 : title.toString(), children: [
+      !isLastNode && /* @__PURE__ */ jsx("span", { css: [treeSelectOptionStyle.switcher(theme), (_e = styles == null ? void 0 : styles.switcher) == null ? void 0 : _e.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:TreeSelectOption;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], onClick: handleSwitcherClick, children: getSwitcherIcon() }),
+      treeCheckable && /* @__PURE__ */ jsx(Checkbox, { checked: selected, disabled, indeterminate: isIndeterminate, onClick: handleClick }),
+      /* @__PURE__ */ jsxs("div", { css: [treeSelectOptionStyle.item(theme), (_f = styles == null ? void 0 : styles.item) == null ? void 0 : _f.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:TreeSelectOption;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9idWlsZHMvZnJvbnRlbmQvbGlicy91aS1raXQvc3JjL2NvbXBvbmVudHMvVHJlZVNlbGVjdC9jb21wb25lbnRzL1RyZWVTZWxlY3RPcHRpb24vVHJlZVNlbGVjdE9wdGlvbi50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBa0lhIiwiZmlsZSI6Ii9idWlsZHMvZnJvbnRlbmQvbGlicy91aS1raXQvc3JjL2NvbXBvbmVudHMvVHJlZVNlbGVjdC9jb21wb25lbnRzL1RyZWVTZWxlY3RPcHRpb24vVHJlZVNlbGVjdE9wdGlvbi50c3giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB1c2VCYXNlU2VsZWN0Q29udGV4dCB9IGZyb20gXCJjb21wb25lbnRzL0Jhc2VTZWxlY3QvY29udGV4dHMvQmFzZVNlbGVjdENvbnRleHRcIjtcbmltcG9ydCB7IG1lbW8sIHVzZUNvbnRleHQsIHVzZU1lbW8sIHVzZVJlZiwgdHlwZSBGQyB9IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHR5cGUgeyBUcmVlU2VsZWN0T3B0aW9uUHJvcHMgfSBmcm9tIFwiLi9UcmVlU2VsZWN0T3B0aW9uLnR5cGVzXCI7XG5pbXBvcnQgeyB1c2VUaGVtZSB9IGZyb20gXCJob29rcy91c2VUaGVtZVwiO1xuaW1wb3J0IHsgQ2FyZXREb3duT3V0bGluZWQsIENhcmV0UmlnaHRPdXRsaW5lZCwgQ2hlY2tPdXRsaW5lZCB9IGZyb20gXCJAaW5mb21heGltdW0vaWNvbnNcIjtcbmltcG9ydCB7IENoZWNrYm94IH0gZnJvbSBcImNvbXBvbmVudHMvQ2hlY2tib3hcIjtcbmltcG9ydCB7IGdldFRyZWVTZWxlY3RPcHRpb25TdHlsZSB9IGZyb20gXCIuL1RyZWVTZWxlY3RPcHRpb24uc3R5bGVzXCI7XG5pbXBvcnQgeyBMb2FkaW5nT3V0bGluZWQgfSBmcm9tIFwiaWNvbnMvaWNvbnNcIjtcbmltcG9ydCB7IHRyZWVTZWxlY3RDb250ZXh0IH0gZnJvbSBcImNvbXBvbmVudHMvVHJlZVNlbGVjdC9jb250ZXh0cy90cmVlU2VsZWN0Q29udGV4dFwiO1xuaW1wb3J0IHsgdXNlUmVzaXplT2JzZXJ2ZXIgfSBmcm9tIFwiaG9va3MvdXNlUmVzaXplT2JzZXJ2ZXJcIjtcbmltcG9ydCB0eXBlIHsgVHJlZVNlbGVjdE5vZGVWYWx1ZSB9IGZyb20gXCJjb21wb25lbnRzL1RyZWVTZWxlY3QvVHJlZVNlbGVjdC50eXBlc1wiO1xuXG5leHBvcnQgY29uc3QgVHJlZVNlbGVjdE9wdGlvbjogRkM8VHJlZVNlbGVjdE9wdGlvblByb3BzPiA9IG1lbW8oKHByb3BzKSA9PiB7XG4gIGNvbnN0IHsgdGl0bGUsIGljb24sIGxlYWYsIGNoaWxkcmVuLCBkaXNhYmxlZCwgaW5kZXgsIGl0ZW1LZXk6IGtleSwgc3R5bGVzIH0gPSBwcm9wcztcblxuICBjb25zdCB0aGVtZSA9IHVzZVRoZW1lKCk7XG5cbiAgY29uc3QgeyBjdXJyZW50VmFsdWUsIG1vZGUsIHJlbW92ZVZhbHVlLCBzZXRWYWx1ZSwgY2xvc2VPcHRpb25MaXN0IH0gPVxuICAgIHVzZUJhc2VTZWxlY3RDb250ZXh0PFRyZWVTZWxlY3ROb2RlVmFsdWU+KCk7XG4gIGNvbnN0IHtcbiAgICB0cmVlQ2hlY2thYmxlLFxuICAgIG5vZGVEYXRhTWFwLFxuICAgIGV4cGFuZGVkS2V5cyxcbiAgICBpc0FzeW5jTG9hZGluZyxcbiAgICBsb2FkaW5nS2V5cyxcbiAgICBvblN3aXRjaGVyQ2xpY2ssXG4gICAgY2hhbmdlRWxlbWVudFNpemUsXG4gICAgZ2V0Q3VycmVudFNlbGVjdGluZ0tleSxcbiAgICBvbkNoZWNrYWJsZUNsaWNrLFxuICB9ID0gdXNlQ29udGV4dCh0cmVlU2VsZWN0Q29udGV4dCk7XG5cbiAgY29uc3QgaXNPcGVuID0gdXNlTWVtbygoKSA9PiBleHBhbmRlZEtleXMuaW5jbHVkZXMoa2V5KSwgW2V4cGFuZGVkS2V5cywga2V5XSk7XG5cbiAgY29uc3QgZWxlbWVudFJlZiA9IHVzZVJlZjxIVE1MRGl2RWxlbWVudCB8IG51bGw+KG51bGwpO1xuXG4gIGNvbnN0IGlzU2VsZWN0aW5nID0gZ2V0Q3VycmVudFNlbGVjdGluZ0tleSgpID09PSBrZXk7XG4gIGNvbnN0IHNlbGVjdGVkID0gY3VycmVudFZhbHVlLmluY2x1ZGVzKGtleSk7XG4gIGNvbnN0IGxvYWRpbmcgPSBsb2FkaW5nS2V5cy5pbmNsdWRlcyhrZXkpO1xuICBjb25zdCBpc0xhc3ROb2RlID0gbGVhZiB8fCAhY2hpbGRyZW4gfHwgKGNoaWxkcmVuPy5sZW5ndGggPT09IDAgJiYgIWlzQXN5bmNMb2FkaW5nKTtcbiAgY29uc3QgcGFyZW50c0NvdW50ZXIgPSBub2RlRGF0YU1hcC5nZXQoa2V5KT8ucGFyZW50S2V5cy5sZW5ndGggPz8gMDtcbiAgY29uc3QgaXNJbmRldGVybWluYXRlID1cbiAgICAhc2VsZWN0ZWQgJiYgbm9kZURhdGFNYXAuZ2V0KGtleSk/LmNoaWxkcmVuS2V5cy5zb21lKChrZXkpID0+IGN1cnJlbnRWYWx1ZS5pbmNsdWRlcyhrZXkpKTtcblxuICB1c2VSZXNpemVPYnNlcnZlcihlbGVtZW50UmVmLCAoZW50cmllcykgPT4ge1xuICAgIGlmIChwYXJlbnRzQ291bnRlciA+IDApIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBjb25zdCBlbnRyeSA9IGVudHJpZXNbMF07XG4gICAgY2hhbmdlRWxlbWVudFNpemUoaW5kZXgsIGVudHJ5LmNvbnRlbnRSZWN0LmhlaWdodCk7XG4gIH0pO1xuXG4gIGNvbnN0IGhhbmRsZUNsaWNrID0gKCkgPT4ge1xuICAgIGlmIChkaXNhYmxlZCkge1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIGlmICh0cmVlQ2hlY2thYmxlKSB7XG4gICAgICBvbkNoZWNrYWJsZUNsaWNrKGtleSk7XG5cbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBpZiAobW9kZSA9PT0gXCJtdWx0aXBsZVwiKSB7XG4gICAgICBpZiAoc2VsZWN0ZWQpIHtcbiAgICAgICAgcmVtb3ZlVmFsdWUoa2V5KTtcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIHNldFZhbHVlKGtleSk7XG4gICAgICB9XG5cbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBzZXRWYWx1ZShrZXkpO1xuICAgIGNsb3NlT3B0aW9uTGlzdCgpO1xuICB9O1xuXG4gIGNvbnN0IGdldFN3aXRjaGVySWNvbiA9ICgpID0+IHtcbiAgICBpZiAobG9hZGluZykge1xuICAgICAgcmV0dXJuIDxMb2FkaW5nT3V0bGluZWQgLz47XG4gICAgfVxuXG4gICAgaWYgKGlzT3Blbikge1xuICAgICAgcmV0dXJuIDxDYXJldERvd25PdXRsaW5lZCAvPjtcbiAgICB9XG5cbiAgICByZXR1cm4gPENhcmV0UmlnaHRPdXRsaW5lZCAvPjtcbiAgfTtcblxuICBjb25zdCBoYW5kbGVTd2l0Y2hlckNsaWNrID0gKCkgPT4ge1xuICAgIGlmIChsb2FkaW5nKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgb25Td2l0Y2hlckNsaWNrKGtleSk7XG4gIH07XG5cbiAgY29uc3QgdHJlZVNlbGVjdE9wdGlvblN0eWxlID0gZ2V0VHJlZVNlbGVjdE9wdGlvblN0eWxlKHtcbiAgICBkaXNhYmxlZDogISFkaXNhYmxlZCxcbiAgICBsb2FkaW5nOiAhIWxvYWRpbmcsXG4gICAgc2VsZWN0ZWQsXG4gICAgaXNTZWxlY3RpbmcsXG4gICAgdHJlZUNoZWNrYWJsZSxcbiAgICBpc0xhc3ROb2RlLFxuICB9KTtcblxuICByZXR1cm4gKFxuICAgIDxkaXYgcmVmPXtlbGVtZW50UmVmfSBjc3M9e1t0cmVlU2VsZWN0T3B0aW9uU3R5bGUud3JhcHBlcigpLCBzdHlsZXM/LndyYXBwZXI/LigpXX0+XG4gICAgICA8ZGl2XG4gICAgICAgIGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5oZWFkZXIodGhlbWUpLCBzdHlsZXM/LmhlYWRlcj8uKHRoZW1lKV19XG4gICAgICAgIHRpdGxlPXt0aXRsZT8udG9TdHJpbmcoKX1cbiAgICAgID5cbiAgICAgICAgeyFpc0xhc3ROb2RlICYmIChcbiAgICAgICAgICA8c3BhblxuICAgICAgICAgICAgY3NzPXtbdHJlZVNlbGVjdE9wdGlvblN0eWxlLnN3aXRjaGVyKHRoZW1lKSwgc3R5bGVzPy5zd2l0Y2hlcj8uKHRoZW1lKV19XG4gICAgICAgICAgICBvbkNsaWNrPXtoYW5kbGVTd2l0Y2hlckNsaWNrfVxuICAgICAgICAgID5cbiAgICAgICAgICAgIHtnZXRTd2l0Y2hlckljb24oKX1cbiAgICAgICAgICA8L3NwYW4+XG4gICAgICAgICl9XG5cbiAgICAgICAge3RyZWVDaGVja2FibGUgJiYgKFxuICAgICAgICAgIDxDaGVja2JveFxuICAgICAgICAgICAgY2hlY2tlZD17c2VsZWN0ZWR9XG4gICAgICAgICAgICBkaXNhYmxlZD17ZGlzYWJsZWR9XG4gICAgICAgICAgICBpbmRldGVybWluYXRlPXtpc0luZGV0ZXJtaW5hdGV9XG4gICAgICAgICAgICBvbkNsaWNrPXtoYW5kbGVDbGlja31cbiAgICAgICAgICAvPlxuICAgICAgICApfVxuXG4gICAgICAgIDxkaXYgY3NzPXtbdHJlZVNlbGVjdE9wdGlvblN0eWxlLml0ZW0odGhlbWUpLCBzdHlsZXM/Lml0ZW0/Lih0aGVtZSldfSBvbkNsaWNrPXtoYW5kbGVDbGlja30+XG4gICAgICAgICAgPHNwYW4gY3NzPXtbdHJlZVNlbGVjdE9wdGlvblN0eWxlLmNvbnRlbnQodGhlbWUpLCBzdHlsZXM/LmNvbnRlbnQ/Lih0aGVtZSldfT5cbiAgICAgICAgICAgIHtpY29uICYmIChcbiAgICAgICAgICAgICAgPHNwYW4gY3NzPXtbdHJlZVNlbGVjdE9wdGlvblN0eWxlLmljb24odGhlbWUpLCBzdHlsZXM/Lmljb24/Lih0aGVtZSldfT57aWNvbn08L3NwYW4+XG4gICAgICAgICAgICApfVxuICAgICAgICAgICAgPHNwYW4gY3NzPXtbdHJlZVNlbGVjdE9wdGlvblN0eWxlLnRleHQodGhlbWUpLCBzdHlsZXM/LnRleHQ/Lih0aGVtZSldfT57dGl0bGV9PC9zcGFuPlxuICAgICAgICAgIDwvc3Bhbj5cblxuICAgICAgICAgIHtzZWxlY3RlZCAmJiAhdHJlZUNoZWNrYWJsZSAmJiAoXG4gICAgICAgICAgICA8c3BhbiBjc3M9e1t0cmVlU2VsZWN0T3B0aW9uU3R5bGUuaWNvbih0aGVtZSksIHN0eWxlcz8uaWNvbj8uKHRoZW1lKV19PlxuICAgICAgICAgICAgICA8Q2hlY2tPdXRsaW5lZCAvPlxuICAgICAgICAgICAgPC9zcGFuPlxuICAgICAgICAgICl9XG4gICAgICAgIDwvZGl2PlxuICAgICAgPC9kaXY+XG5cbiAgICAgIHtpc09wZW4gJiYgY2hpbGRyZW4gJiYgIWxvYWRpbmcgJiYgKFxuICAgICAgICA8ZGl2IGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5jaGlsZHJlbih0aGVtZSksIHN0eWxlcz8uY2hpbGRyZW4/Lih0aGVtZSldfT5cbiAgICAgICAgICB7Y2hpbGRyZW4/Lm1hcCgoY2hpbGQsIGluZGV4KSA9PiAoXG4gICAgICAgICAgICA8VHJlZVNlbGVjdE9wdGlvbiB7Li4uY2hpbGR9IGluZGV4PXtpbmRleH0gaXRlbUtleT17Y2hpbGQua2V5fSBrZXk9e2NoaWxkLmtleX0gLz5cbiAgICAgICAgICApKX1cbiAgICAgICAgPC9kaXY+XG4gICAgICApfVxuICAgIDwvZGl2PlxuICApO1xufSk7XG4iXX0= */"], onClick: handleClick, children: [
+        /* @__PURE__ */ jsxs("span", { css: [treeSelectOptionStyle.content(theme), (_g = styles == null ? void 0 : styles.content) == null ? void 0 : _g.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:TreeSelectOption;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], children: [
+          icon && /* @__PURE__ */ jsx("span", { css: [treeSelectOptionStyle.icon(theme), (_h = styles == null ? void 0 : styles.icon) == null ? void 0 : _h.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:TreeSelectOption;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], children: icon }),
+          /* @__PURE__ */ jsx("span", { css: [treeSelectOptionStyle.text(theme), (_i = styles == null ? void 0 : styles.text) == null ? void 0 : _i.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:TreeSelectOption;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9idWlsZHMvZnJvbnRlbmQvbGlicy91aS1raXQvc3JjL2NvbXBvbmVudHMvVHJlZVNlbGVjdC9jb21wb25lbnRzL1RyZWVTZWxlY3RPcHRpb24vVHJlZVNlbGVjdE9wdGlvbi50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBdUlrQiIsImZpbGUiOiIvYnVpbGRzL2Zyb250ZW5kL2xpYnMvdWkta2l0L3NyYy9jb21wb25lbnRzL1RyZWVTZWxlY3QvY29tcG9uZW50cy9UcmVlU2VsZWN0T3B0aW9uL1RyZWVTZWxlY3RPcHRpb24udHN4Iiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdXNlQmFzZVNlbGVjdENvbnRleHQgfSBmcm9tIFwiY29tcG9uZW50cy9CYXNlU2VsZWN0L2NvbnRleHRzL0Jhc2VTZWxlY3RDb250ZXh0XCI7XG5pbXBvcnQgeyBtZW1vLCB1c2VDb250ZXh0LCB1c2VNZW1vLCB1c2VSZWYsIHR5cGUgRkMgfSBmcm9tIFwicmVhY3RcIjtcbmltcG9ydCB0eXBlIHsgVHJlZVNlbGVjdE9wdGlvblByb3BzIH0gZnJvbSBcIi4vVHJlZVNlbGVjdE9wdGlvbi50eXBlc1wiO1xuaW1wb3J0IHsgdXNlVGhlbWUgfSBmcm9tIFwiaG9va3MvdXNlVGhlbWVcIjtcbmltcG9ydCB7IENhcmV0RG93bk91dGxpbmVkLCBDYXJldFJpZ2h0T3V0bGluZWQsIENoZWNrT3V0bGluZWQgfSBmcm9tIFwiQGluZm9tYXhpbXVtL2ljb25zXCI7XG5pbXBvcnQgeyBDaGVja2JveCB9IGZyb20gXCJjb21wb25lbnRzL0NoZWNrYm94XCI7XG5pbXBvcnQgeyBnZXRUcmVlU2VsZWN0T3B0aW9uU3R5bGUgfSBmcm9tIFwiLi9UcmVlU2VsZWN0T3B0aW9uLnN0eWxlc1wiO1xuaW1wb3J0IHsgTG9hZGluZ091dGxpbmVkIH0gZnJvbSBcImljb25zL2ljb25zXCI7XG5pbXBvcnQgeyB0cmVlU2VsZWN0Q29udGV4dCB9IGZyb20gXCJjb21wb25lbnRzL1RyZWVTZWxlY3QvY29udGV4dHMvdHJlZVNlbGVjdENvbnRleHRcIjtcbmltcG9ydCB7IHVzZVJlc2l6ZU9ic2VydmVyIH0gZnJvbSBcImhvb2tzL3VzZVJlc2l6ZU9ic2VydmVyXCI7XG5pbXBvcnQgdHlwZSB7IFRyZWVTZWxlY3ROb2RlVmFsdWUgfSBmcm9tIFwiY29tcG9uZW50cy9UcmVlU2VsZWN0L1RyZWVTZWxlY3QudHlwZXNcIjtcblxuZXhwb3J0IGNvbnN0IFRyZWVTZWxlY3RPcHRpb246IEZDPFRyZWVTZWxlY3RPcHRpb25Qcm9wcz4gPSBtZW1vKChwcm9wcykgPT4ge1xuICBjb25zdCB7IHRpdGxlLCBpY29uLCBsZWFmLCBjaGlsZHJlbiwgZGlzYWJsZWQsIGluZGV4LCBpdGVtS2V5OiBrZXksIHN0eWxlcyB9ID0gcHJvcHM7XG5cbiAgY29uc3QgdGhlbWUgPSB1c2VUaGVtZSgpO1xuXG4gIGNvbnN0IHsgY3VycmVudFZhbHVlLCBtb2RlLCByZW1vdmVWYWx1ZSwgc2V0VmFsdWUsIGNsb3NlT3B0aW9uTGlzdCB9ID1cbiAgICB1c2VCYXNlU2VsZWN0Q29udGV4dDxUcmVlU2VsZWN0Tm9kZVZhbHVlPigpO1xuICBjb25zdCB7XG4gICAgdHJlZUNoZWNrYWJsZSxcbiAgICBub2RlRGF0YU1hcCxcbiAgICBleHBhbmRlZEtleXMsXG4gICAgaXNBc3luY0xvYWRpbmcsXG4gICAgbG9hZGluZ0tleXMsXG4gICAgb25Td2l0Y2hlckNsaWNrLFxuICAgIGNoYW5nZUVsZW1lbnRTaXplLFxuICAgIGdldEN1cnJlbnRTZWxlY3RpbmdLZXksXG4gICAgb25DaGVja2FibGVDbGljayxcbiAgfSA9IHVzZUNvbnRleHQodHJlZVNlbGVjdENvbnRleHQpO1xuXG4gIGNvbnN0IGlzT3BlbiA9IHVzZU1lbW8oKCkgPT4gZXhwYW5kZWRLZXlzLmluY2x1ZGVzKGtleSksIFtleHBhbmRlZEtleXMsIGtleV0pO1xuXG4gIGNvbnN0IGVsZW1lbnRSZWYgPSB1c2VSZWY8SFRNTERpdkVsZW1lbnQgfCBudWxsPihudWxsKTtcblxuICBjb25zdCBpc1NlbGVjdGluZyA9IGdldEN1cnJlbnRTZWxlY3RpbmdLZXkoKSA9PT0ga2V5O1xuICBjb25zdCBzZWxlY3RlZCA9IGN1cnJlbnRWYWx1ZS5pbmNsdWRlcyhrZXkpO1xuICBjb25zdCBsb2FkaW5nID0gbG9hZGluZ0tleXMuaW5jbHVkZXMoa2V5KTtcbiAgY29uc3QgaXNMYXN0Tm9kZSA9IGxlYWYgfHwgIWNoaWxkcmVuIHx8IChjaGlsZHJlbj8ubGVuZ3RoID09PSAwICYmICFpc0FzeW5jTG9hZGluZyk7XG4gIGNvbnN0IHBhcmVudHNDb3VudGVyID0gbm9kZURhdGFNYXAuZ2V0KGtleSk/LnBhcmVudEtleXMubGVuZ3RoID8/IDA7XG4gIGNvbnN0IGlzSW5kZXRlcm1pbmF0ZSA9XG4gICAgIXNlbGVjdGVkICYmIG5vZGVEYXRhTWFwLmdldChrZXkpPy5jaGlsZHJlbktleXMuc29tZSgoa2V5KSA9PiBjdXJyZW50VmFsdWUuaW5jbHVkZXMoa2V5KSk7XG5cbiAgdXNlUmVzaXplT2JzZXJ2ZXIoZWxlbWVudFJlZiwgKGVudHJpZXMpID0+IHtcbiAgICBpZiAocGFyZW50c0NvdW50ZXIgPiAwKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgY29uc3QgZW50cnkgPSBlbnRyaWVzWzBdO1xuICAgIGNoYW5nZUVsZW1lbnRTaXplKGluZGV4LCBlbnRyeS5jb250ZW50UmVjdC5oZWlnaHQpO1xuICB9KTtcblxuICBjb25zdCBoYW5kbGVDbGljayA9ICgpID0+IHtcbiAgICBpZiAoZGlzYWJsZWQpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBpZiAodHJlZUNoZWNrYWJsZSkge1xuICAgICAgb25DaGVja2FibGVDbGljayhrZXkpO1xuXG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgaWYgKG1vZGUgPT09IFwibXVsdGlwbGVcIikge1xuICAgICAgaWYgKHNlbGVjdGVkKSB7XG4gICAgICAgIHJlbW92ZVZhbHVlKGtleSk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICBzZXRWYWx1ZShrZXkpO1xuICAgICAgfVxuXG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgc2V0VmFsdWUoa2V5KTtcbiAgICBjbG9zZU9wdGlvbkxpc3QoKTtcbiAgfTtcblxuICBjb25zdCBnZXRTd2l0Y2hlckljb24gPSAoKSA9PiB7XG4gICAgaWYgKGxvYWRpbmcpIHtcbiAgICAgIHJldHVybiA8TG9hZGluZ091dGxpbmVkIC8+O1xuICAgIH1cblxuICAgIGlmIChpc09wZW4pIHtcbiAgICAgIHJldHVybiA8Q2FyZXREb3duT3V0bGluZWQgLz47XG4gICAgfVxuXG4gICAgcmV0dXJuIDxDYXJldFJpZ2h0T3V0bGluZWQgLz47XG4gIH07XG5cbiAgY29uc3QgaGFuZGxlU3dpdGNoZXJDbGljayA9ICgpID0+IHtcbiAgICBpZiAobG9hZGluZykge1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIG9uU3dpdGNoZXJDbGljayhrZXkpO1xuICB9O1xuXG4gIGNvbnN0IHRyZWVTZWxlY3RPcHRpb25TdHlsZSA9IGdldFRyZWVTZWxlY3RPcHRpb25TdHlsZSh7XG4gICAgZGlzYWJsZWQ6ICEhZGlzYWJsZWQsXG4gICAgbG9hZGluZzogISFsb2FkaW5nLFxuICAgIHNlbGVjdGVkLFxuICAgIGlzU2VsZWN0aW5nLFxuICAgIHRyZWVDaGVja2FibGUsXG4gICAgaXNMYXN0Tm9kZSxcbiAgfSk7XG5cbiAgcmV0dXJuIChcbiAgICA8ZGl2IHJlZj17ZWxlbWVudFJlZn0gY3NzPXtbdHJlZVNlbGVjdE9wdGlvblN0eWxlLndyYXBwZXIoKSwgc3R5bGVzPy53cmFwcGVyPy4oKV19PlxuICAgICAgPGRpdlxuICAgICAgICBjc3M9e1t0cmVlU2VsZWN0T3B0aW9uU3R5bGUuaGVhZGVyKHRoZW1lKSwgc3R5bGVzPy5oZWFkZXI/Lih0aGVtZSldfVxuICAgICAgICB0aXRsZT17dGl0bGU/LnRvU3RyaW5nKCl9XG4gICAgICA+XG4gICAgICAgIHshaXNMYXN0Tm9kZSAmJiAoXG4gICAgICAgICAgPHNwYW5cbiAgICAgICAgICAgIGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5zd2l0Y2hlcih0aGVtZSksIHN0eWxlcz8uc3dpdGNoZXI/Lih0aGVtZSldfVxuICAgICAgICAgICAgb25DbGljaz17aGFuZGxlU3dpdGNoZXJDbGlja31cbiAgICAgICAgICA+XG4gICAgICAgICAgICB7Z2V0U3dpdGNoZXJJY29uKCl9XG4gICAgICAgICAgPC9zcGFuPlxuICAgICAgICApfVxuXG4gICAgICAgIHt0cmVlQ2hlY2thYmxlICYmIChcbiAgICAgICAgICA8Q2hlY2tib3hcbiAgICAgICAgICAgIGNoZWNrZWQ9e3NlbGVjdGVkfVxuICAgICAgICAgICAgZGlzYWJsZWQ9e2Rpc2FibGVkfVxuICAgICAgICAgICAgaW5kZXRlcm1pbmF0ZT17aXNJbmRldGVybWluYXRlfVxuICAgICAgICAgICAgb25DbGljaz17aGFuZGxlQ2xpY2t9XG4gICAgICAgICAgLz5cbiAgICAgICAgKX1cblxuICAgICAgICA8ZGl2IGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5pdGVtKHRoZW1lKSwgc3R5bGVzPy5pdGVtPy4odGhlbWUpXX0gb25DbGljaz17aGFuZGxlQ2xpY2t9PlxuICAgICAgICAgIDxzcGFuIGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5jb250ZW50KHRoZW1lKSwgc3R5bGVzPy5jb250ZW50Py4odGhlbWUpXX0+XG4gICAgICAgICAgICB7aWNvbiAmJiAoXG4gICAgICAgICAgICAgIDxzcGFuIGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5pY29uKHRoZW1lKSwgc3R5bGVzPy5pY29uPy4odGhlbWUpXX0+e2ljb259PC9zcGFuPlxuICAgICAgICAgICAgKX1cbiAgICAgICAgICAgIDxzcGFuIGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS50ZXh0KHRoZW1lKSwgc3R5bGVzPy50ZXh0Py4odGhlbWUpXX0+e3RpdGxlfTwvc3Bhbj5cbiAgICAgICAgICA8L3NwYW4+XG5cbiAgICAgICAgICB7c2VsZWN0ZWQgJiYgIXRyZWVDaGVja2FibGUgJiYgKFxuICAgICAgICAgICAgPHNwYW4gY3NzPXtbdHJlZVNlbGVjdE9wdGlvblN0eWxlLmljb24odGhlbWUpLCBzdHlsZXM/Lmljb24/Lih0aGVtZSldfT5cbiAgICAgICAgICAgICAgPENoZWNrT3V0bGluZWQgLz5cbiAgICAgICAgICAgIDwvc3Bhbj5cbiAgICAgICAgICApfVxuICAgICAgICA8L2Rpdj5cbiAgICAgIDwvZGl2PlxuXG4gICAgICB7aXNPcGVuICYmIGNoaWxkcmVuICYmICFsb2FkaW5nICYmIChcbiAgICAgICAgPGRpdiBjc3M9e1t0cmVlU2VsZWN0T3B0aW9uU3R5bGUuY2hpbGRyZW4odGhlbWUpLCBzdHlsZXM/LmNoaWxkcmVuPy4odGhlbWUpXX0+XG4gICAgICAgICAge2NoaWxkcmVuPy5tYXAoKGNoaWxkLCBpbmRleCkgPT4gKFxuICAgICAgICAgICAgPFRyZWVTZWxlY3RPcHRpb24gey4uLmNoaWxkfSBpbmRleD17aW5kZXh9IGl0ZW1LZXk9e2NoaWxkLmtleX0ga2V5PXtjaGlsZC5rZXl9IC8+XG4gICAgICAgICAgKSl9XG4gICAgICAgIDwvZGl2PlxuICAgICAgKX1cbiAgICA8L2Rpdj5cbiAgKTtcbn0pO1xuIl19 */"], children: title })
+        ] }),
+        selected && !treeCheckable && /* @__PURE__ */ jsx("span", { css: [treeSelectOptionStyle.icon(theme), (_j = styles == null ? void 0 : styles.icon) == null ? void 0 : _j.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:TreeSelectOption;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9idWlsZHMvZnJvbnRlbmQvbGlicy91aS1raXQvc3JjL2NvbXBvbmVudHMvVHJlZVNlbGVjdC9jb21wb25lbnRzL1RyZWVTZWxlY3RPcHRpb24vVHJlZVNlbGVjdE9wdGlvbi50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBMklrQiIsImZpbGUiOiIvYnVpbGRzL2Zyb250ZW5kL2xpYnMvdWkta2l0L3NyYy9jb21wb25lbnRzL1RyZWVTZWxlY3QvY29tcG9uZW50cy9UcmVlU2VsZWN0T3B0aW9uL1RyZWVTZWxlY3RPcHRpb24udHN4Iiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdXNlQmFzZVNlbGVjdENvbnRleHQgfSBmcm9tIFwiY29tcG9uZW50cy9CYXNlU2VsZWN0L2NvbnRleHRzL0Jhc2VTZWxlY3RDb250ZXh0XCI7XG5pbXBvcnQgeyBtZW1vLCB1c2VDb250ZXh0LCB1c2VNZW1vLCB1c2VSZWYsIHR5cGUgRkMgfSBmcm9tIFwicmVhY3RcIjtcbmltcG9ydCB0eXBlIHsgVHJlZVNlbGVjdE9wdGlvblByb3BzIH0gZnJvbSBcIi4vVHJlZVNlbGVjdE9wdGlvbi50eXBlc1wiO1xuaW1wb3J0IHsgdXNlVGhlbWUgfSBmcm9tIFwiaG9va3MvdXNlVGhlbWVcIjtcbmltcG9ydCB7IENhcmV0RG93bk91dGxpbmVkLCBDYXJldFJpZ2h0T3V0bGluZWQsIENoZWNrT3V0bGluZWQgfSBmcm9tIFwiQGluZm9tYXhpbXVtL2ljb25zXCI7XG5pbXBvcnQgeyBDaGVja2JveCB9IGZyb20gXCJjb21wb25lbnRzL0NoZWNrYm94XCI7XG5pbXBvcnQgeyBnZXRUcmVlU2VsZWN0T3B0aW9uU3R5bGUgfSBmcm9tIFwiLi9UcmVlU2VsZWN0T3B0aW9uLnN0eWxlc1wiO1xuaW1wb3J0IHsgTG9hZGluZ091dGxpbmVkIH0gZnJvbSBcImljb25zL2ljb25zXCI7XG5pbXBvcnQgeyB0cmVlU2VsZWN0Q29udGV4dCB9IGZyb20gXCJjb21wb25lbnRzL1RyZWVTZWxlY3QvY29udGV4dHMvdHJlZVNlbGVjdENvbnRleHRcIjtcbmltcG9ydCB7IHVzZVJlc2l6ZU9ic2VydmVyIH0gZnJvbSBcImhvb2tzL3VzZVJlc2l6ZU9ic2VydmVyXCI7XG5pbXBvcnQgdHlwZSB7IFRyZWVTZWxlY3ROb2RlVmFsdWUgfSBmcm9tIFwiY29tcG9uZW50cy9UcmVlU2VsZWN0L1RyZWVTZWxlY3QudHlwZXNcIjtcblxuZXhwb3J0IGNvbnN0IFRyZWVTZWxlY3RPcHRpb246IEZDPFRyZWVTZWxlY3RPcHRpb25Qcm9wcz4gPSBtZW1vKChwcm9wcykgPT4ge1xuICBjb25zdCB7IHRpdGxlLCBpY29uLCBsZWFmLCBjaGlsZHJlbiwgZGlzYWJsZWQsIGluZGV4LCBpdGVtS2V5OiBrZXksIHN0eWxlcyB9ID0gcHJvcHM7XG5cbiAgY29uc3QgdGhlbWUgPSB1c2VUaGVtZSgpO1xuXG4gIGNvbnN0IHsgY3VycmVudFZhbHVlLCBtb2RlLCByZW1vdmVWYWx1ZSwgc2V0VmFsdWUsIGNsb3NlT3B0aW9uTGlzdCB9ID1cbiAgICB1c2VCYXNlU2VsZWN0Q29udGV4dDxUcmVlU2VsZWN0Tm9kZVZhbHVlPigpO1xuICBjb25zdCB7XG4gICAgdHJlZUNoZWNrYWJsZSxcbiAgICBub2RlRGF0YU1hcCxcbiAgICBleHBhbmRlZEtleXMsXG4gICAgaXNBc3luY0xvYWRpbmcsXG4gICAgbG9hZGluZ0tleXMsXG4gICAgb25Td2l0Y2hlckNsaWNrLFxuICAgIGNoYW5nZUVsZW1lbnRTaXplLFxuICAgIGdldEN1cnJlbnRTZWxlY3RpbmdLZXksXG4gICAgb25DaGVja2FibGVDbGljayxcbiAgfSA9IHVzZUNvbnRleHQodHJlZVNlbGVjdENvbnRleHQpO1xuXG4gIGNvbnN0IGlzT3BlbiA9IHVzZU1lbW8oKCkgPT4gZXhwYW5kZWRLZXlzLmluY2x1ZGVzKGtleSksIFtleHBhbmRlZEtleXMsIGtleV0pO1xuXG4gIGNvbnN0IGVsZW1lbnRSZWYgPSB1c2VSZWY8SFRNTERpdkVsZW1lbnQgfCBudWxsPihudWxsKTtcblxuICBjb25zdCBpc1NlbGVjdGluZyA9IGdldEN1cnJlbnRTZWxlY3RpbmdLZXkoKSA9PT0ga2V5O1xuICBjb25zdCBzZWxlY3RlZCA9IGN1cnJlbnRWYWx1ZS5pbmNsdWRlcyhrZXkpO1xuICBjb25zdCBsb2FkaW5nID0gbG9hZGluZ0tleXMuaW5jbHVkZXMoa2V5KTtcbiAgY29uc3QgaXNMYXN0Tm9kZSA9IGxlYWYgfHwgIWNoaWxkcmVuIHx8IChjaGlsZHJlbj8ubGVuZ3RoID09PSAwICYmICFpc0FzeW5jTG9hZGluZyk7XG4gIGNvbnN0IHBhcmVudHNDb3VudGVyID0gbm9kZURhdGFNYXAuZ2V0KGtleSk/LnBhcmVudEtleXMubGVuZ3RoID8/IDA7XG4gIGNvbnN0IGlzSW5kZXRlcm1pbmF0ZSA9XG4gICAgIXNlbGVjdGVkICYmIG5vZGVEYXRhTWFwLmdldChrZXkpPy5jaGlsZHJlbktleXMuc29tZSgoa2V5KSA9PiBjdXJyZW50VmFsdWUuaW5jbHVkZXMoa2V5KSk7XG5cbiAgdXNlUmVzaXplT2JzZXJ2ZXIoZWxlbWVudFJlZiwgKGVudHJpZXMpID0+IHtcbiAgICBpZiAocGFyZW50c0NvdW50ZXIgPiAwKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgY29uc3QgZW50cnkgPSBlbnRyaWVzWzBdO1xuICAgIGNoYW5nZUVsZW1lbnRTaXplKGluZGV4LCBlbnRyeS5jb250ZW50UmVjdC5oZWlnaHQpO1xuICB9KTtcblxuICBjb25zdCBoYW5kbGVDbGljayA9ICgpID0+IHtcbiAgICBpZiAoZGlzYWJsZWQpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBpZiAodHJlZUNoZWNrYWJsZSkge1xuICAgICAgb25DaGVja2FibGVDbGljayhrZXkpO1xuXG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgaWYgKG1vZGUgPT09IFwibXVsdGlwbGVcIikge1xuICAgICAgaWYgKHNlbGVjdGVkKSB7XG4gICAgICAgIHJlbW92ZVZhbHVlKGtleSk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICBzZXRWYWx1ZShrZXkpO1xuICAgICAgfVxuXG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgc2V0VmFsdWUoa2V5KTtcbiAgICBjbG9zZU9wdGlvbkxpc3QoKTtcbiAgfTtcblxuICBjb25zdCBnZXRTd2l0Y2hlckljb24gPSAoKSA9PiB7XG4gICAgaWYgKGxvYWRpbmcpIHtcbiAgICAgIHJldHVybiA8TG9hZGluZ091dGxpbmVkIC8+O1xuICAgIH1cblxuICAgIGlmIChpc09wZW4pIHtcbiAgICAgIHJldHVybiA8Q2FyZXREb3duT3V0bGluZWQgLz47XG4gICAgfVxuXG4gICAgcmV0dXJuIDxDYXJldFJpZ2h0T3V0bGluZWQgLz47XG4gIH07XG5cbiAgY29uc3QgaGFuZGxlU3dpdGNoZXJDbGljayA9ICgpID0+IHtcbiAgICBpZiAobG9hZGluZykge1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIG9uU3dpdGNoZXJDbGljayhrZXkpO1xuICB9O1xuXG4gIGNvbnN0IHRyZWVTZWxlY3RPcHRpb25TdHlsZSA9IGdldFRyZWVTZWxlY3RPcHRpb25TdHlsZSh7XG4gICAgZGlzYWJsZWQ6ICEhZGlzYWJsZWQsXG4gICAgbG9hZGluZzogISFsb2FkaW5nLFxuICAgIHNlbGVjdGVkLFxuICAgIGlzU2VsZWN0aW5nLFxuICAgIHRyZWVDaGVja2FibGUsXG4gICAgaXNMYXN0Tm9kZSxcbiAgfSk7XG5cbiAgcmV0dXJuIChcbiAgICA8ZGl2IHJlZj17ZWxlbWVudFJlZn0gY3NzPXtbdHJlZVNlbGVjdE9wdGlvblN0eWxlLndyYXBwZXIoKSwgc3R5bGVzPy53cmFwcGVyPy4oKV19PlxuICAgICAgPGRpdlxuICAgICAgICBjc3M9e1t0cmVlU2VsZWN0T3B0aW9uU3R5bGUuaGVhZGVyKHRoZW1lKSwgc3R5bGVzPy5oZWFkZXI/Lih0aGVtZSldfVxuICAgICAgICB0aXRsZT17dGl0bGU/LnRvU3RyaW5nKCl9XG4gICAgICA+XG4gICAgICAgIHshaXNMYXN0Tm9kZSAmJiAoXG4gICAgICAgICAgPHNwYW5cbiAgICAgICAgICAgIGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5zd2l0Y2hlcih0aGVtZSksIHN0eWxlcz8uc3dpdGNoZXI/Lih0aGVtZSldfVxuICAgICAgICAgICAgb25DbGljaz17aGFuZGxlU3dpdGNoZXJDbGlja31cbiAgICAgICAgICA+XG4gICAgICAgICAgICB7Z2V0U3dpdGNoZXJJY29uKCl9XG4gICAgICAgICAgPC9zcGFuPlxuICAgICAgICApfVxuXG4gICAgICAgIHt0cmVlQ2hlY2thYmxlICYmIChcbiAgICAgICAgICA8Q2hlY2tib3hcbiAgICAgICAgICAgIGNoZWNrZWQ9e3NlbGVjdGVkfVxuICAgICAgICAgICAgZGlzYWJsZWQ9e2Rpc2FibGVkfVxuICAgICAgICAgICAgaW5kZXRlcm1pbmF0ZT17aXNJbmRldGVybWluYXRlfVxuICAgICAgICAgICAgb25DbGljaz17aGFuZGxlQ2xpY2t9XG4gICAgICAgICAgLz5cbiAgICAgICAgKX1cblxuICAgICAgICA8ZGl2IGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5pdGVtKHRoZW1lKSwgc3R5bGVzPy5pdGVtPy4odGhlbWUpXX0gb25DbGljaz17aGFuZGxlQ2xpY2t9PlxuICAgICAgICAgIDxzcGFuIGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5jb250ZW50KHRoZW1lKSwgc3R5bGVzPy5jb250ZW50Py4odGhlbWUpXX0+XG4gICAgICAgICAgICB7aWNvbiAmJiAoXG4gICAgICAgICAgICAgIDxzcGFuIGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS5pY29uKHRoZW1lKSwgc3R5bGVzPy5pY29uPy4odGhlbWUpXX0+e2ljb259PC9zcGFuPlxuICAgICAgICAgICAgKX1cbiAgICAgICAgICAgIDxzcGFuIGNzcz17W3RyZWVTZWxlY3RPcHRpb25TdHlsZS50ZXh0KHRoZW1lKSwgc3R5bGVzPy50ZXh0Py4odGhlbWUpXX0+e3RpdGxlfTwvc3Bhbj5cbiAgICAgICAgICA8L3NwYW4+XG5cbiAgICAgICAgICB7c2VsZWN0ZWQgJiYgIXRyZWVDaGVja2FibGUgJiYgKFxuICAgICAgICAgICAgPHNwYW4gY3NzPXtbdHJlZVNlbGVjdE9wdGlvblN0eWxlLmljb24odGhlbWUpLCBzdHlsZXM/Lmljb24/Lih0aGVtZSldfT5cbiAgICAgICAgICAgICAgPENoZWNrT3V0bGluZWQgLz5cbiAgICAgICAgICAgIDwvc3Bhbj5cbiAgICAgICAgICApfVxuICAgICAgICA8L2Rpdj5cbiAgICAgIDwvZGl2PlxuXG4gICAgICB7aXNPcGVuICYmIGNoaWxkcmVuICYmICFsb2FkaW5nICYmIChcbiAgICAgICAgPGRpdiBjc3M9e1t0cmVlU2VsZWN0T3B0aW9uU3R5bGUuY2hpbGRyZW4odGhlbWUpLCBzdHlsZXM/LmNoaWxkcmVuPy4odGhlbWUpXX0+XG4gICAgICAgICAge2NoaWxkcmVuPy5tYXAoKGNoaWxkLCBpbmRleCkgPT4gKFxuICAgICAgICAgICAgPFRyZWVTZWxlY3RPcHRpb24gey4uLmNoaWxkfSBpbmRleD17aW5kZXh9IGl0ZW1LZXk9e2NoaWxkLmtleX0ga2V5PXtjaGlsZC5rZXl9IC8+XG4gICAgICAgICAgKSl9XG4gICAgICAgIDwvZGl2PlxuICAgICAgKX1cbiAgICA8L2Rpdj5cbiAgKTtcbn0pO1xuIl19 */"], children: /* @__PURE__ */ jsx(CheckOutlined, {}) })
+      ] })
+    ] }),
+    isOpen && children && !loading && /* @__PURE__ */ jsx("div", { css: [treeSelectOptionStyle.children(theme), (_k = styles == null ? void 0 : styles.children) == null ? void 0 : _k.call(styles, theme), process.env.NODE_ENV === "production" ? "" : ";label:TreeSelectOption;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], children: children == null ? void 0 : children.map((child, index2) => /* @__PURE__ */ createElement(TreeSelectOption, { ...child, index: index2, itemKey: child.key, key: child.key })) })
+  ] });
+});
+export {
+  TreeSelectOption
+};

package/dist/components/TreeSelect/components/TreeSelectOption/TreeSelectOption.styles.d.ts

@@ -0,0 +1,83 @@
+import { Theme } from 'themes';
+interface GetTreeSelectOptionStyleProps {
+    disabled: boolean;
+    loading: boolean;
+    selected: boolean;
+    isSelecting: boolean;
+    treeCheckable: boolean;
+    isLastNode: boolean;
+}
+export declare const getTreeSelectOptionStyle: ({ disabled, loading, selected, isSelecting, treeCheckable, isLastNode, }: GetTreeSelectOptionStyleProps) => {
+    wrapper: () => {
+        readonly display: "flex";
+        readonly flexDirection: "column";
+    };
+    header: (theme: Theme) => {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly width: "100%";
+        readonly height: 28;
+        readonly gap: 2;
+        readonly boxSizing: "border-box";
+        readonly paddingLeft: number;
+    };
+    switcher: (theme: Theme) => {
+        fontSize: 12;
+        padding: 8;
+        display: string;
+        alignItems: string;
+        borderRadius: 4;
+        color: "#262626" | "#8C8C8C";
+        cursor: string;
+        ":hover, :focus, focus-visible": {
+            background: string;
+            outline: string;
+        };
+    };
+    item: (theme: Theme) => {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly width: "100%";
+        readonly padding: "4px 8px";
+        readonly color: "#262626" | "#8C8C8C" | "#0CB3B3";
+        readonly boxSizing: "border-box";
+        readonly flexWrap: "nowrap";
+        readonly transition: "background .2s, color .2s";
+        readonly cursor: "pointer" | "not-allowed";
+        readonly borderRadius: 4;
+        readonly background: "#F5F5F5" | "unset";
+        readonly ":hover, :focus, focus-visible": {
+            readonly background: "#F5F5F5" | "unset";
+            readonly outline: "none";
+        };
+    };
+    content: (theme: Theme) => {
+        readonly display: "inline-flex";
+        readonly gap: 4;
+        readonly width: string;
+        readonly flex: "1 1 auto";
+        readonly flexWrap: "nowrap";
+    };
+    icon: (theme: Theme) => {
+        fontSize: 16;
+        display: string;
+        justifyContent: string;
+        alignItems: string;
+    };
+    text: (theme: Theme) => {
+        fontFamily: "Roboto";
+        fontSize: 14;
+        lineHeight: "20px";
+        display: string;
+        overflow: string;
+        whiteSpace: string;
+        textOverflow: string;
+        width: string;
+    };
+    children: (theme: Theme) => {
+        readonly display: "flex";
+        readonly flexDirection: "column";
+        readonly paddingLeft: number;
+    };
+};
+export {};