@infomaximum/ui-kit 0.12.11 → 0.13.0

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

@@ -0,0 +1,111 @@
+import { getTreeSelectTokens } from "../../TreeSelect.tokens.js";
+const getColor = (treeSelectTokens, selected, disabled, treeCheckable) => {
+  if (disabled) {
+    return treeSelectTokens.treeSelectOptionTextDisabled;
+  }
+  if (treeCheckable) {
+    return treeSelectTokens.treeSelectOptionText;
+  }
+  if (selected) {
+    return treeSelectTokens.treeSelectOptionTextSelected;
+  }
+  return treeSelectTokens.treeSelectOptionText;
+};
+const getTreeSelectOptionStyle = ({
+  disabled,
+  loading,
+  selected,
+  isSelecting,
+  treeCheckable,
+  isLastNode
+}) => {
+  return {
+    wrapper: () => ({
+      display: "flex",
+      flexDirection: "column"
+    }),
+    header: (theme) => {
+      const treeSelectTokens = getTreeSelectTokens(theme);
+      const lastNodePadding = theme.iconS + treeSelectTokens.treeSelectSwitcherPadding * 2 + treeSelectTokens.treeSelectNodeGap;
+      return {
+        display: "flex",
+        alignItems: "center",
+        width: "100%",
+        height: theme.controlHeightM,
+        gap: treeSelectTokens.treeSelectNodeGap,
+        boxSizing: "border-box",
+        paddingLeft: isLastNode ? lastNodePadding : 0
+      };
+    },
+    switcher: (theme) => {
+      const treeSelectTokens = getTreeSelectTokens(theme);
+      return {
+        fontSize: theme.iconS,
+        padding: treeSelectTokens.treeSelectSwitcherPadding,
+        display: "inline-flex",
+        alignItems: "center",
+        borderRadius: theme.borderRadiusM,
+        color: loading ? treeSelectTokens.treeSelectTextDisabled : treeSelectTokens.treeSelectOptionText,
+        cursor: disabled ? "not-allowed" : "pointer",
+        ":hover, :focus, focus-visible": {
+          background: disabled ? "unset" : treeSelectTokens.treeSelectOptionBgHover,
+          outline: "none"
+        }
+      };
+    },
+    item: (theme) => {
+      const treeSelectTokens = getTreeSelectTokens(theme);
+      return {
+        display: "flex",
+        alignItems: "center",
+        width: "100%",
+        padding: `${treeSelectTokens.treeSelectOptionPaddingVertical}px ${treeSelectTokens.treeSelectOptionPaddingHorizontal}px`,
+        color: getColor(treeSelectTokens, selected, disabled, treeCheckable),
+        boxSizing: "border-box",
+        flexWrap: "nowrap",
+        transition: `background .2s, color .2s`,
+        cursor: disabled ? "not-allowed" : "pointer",
+        borderRadius: theme.borderRadiusM,
+        background: isSelecting ? treeSelectTokens.treeSelectOptionBgHover : "unset",
+        ":hover, :focus, focus-visible": {
+          background: disabled ? "unset" : treeSelectTokens.treeSelectOptionBgHover,
+          outline: "none"
+        }
+      };
+    },
+    content: (theme) => {
+      return {
+        display: "inline-flex",
+        gap: theme.marginXS,
+        width: selected ? `calc(100% - ${theme.marginXS + theme.iconM}px)` : "100%",
+        flex: "1 1 auto",
+        flexWrap: "nowrap"
+      };
+    },
+    icon: (theme) => ({
+      fontSize: theme.iconM,
+      display: "flex",
+      justifyContent: "center",
+      alignItems: "center"
+    }),
+    text: (theme) => ({
+      display: "inline-block",
+      overflow: "hidden",
+      whiteSpace: "nowrap",
+      textOverflow: "ellipsis",
+      width: "100%",
+      ...theme.typography.body2
+    }),
+    children: (theme) => {
+      const treeSelectTokens = getTreeSelectTokens(theme);
+      return {
+        display: "flex",
+        flexDirection: "column",
+        paddingLeft: treeSelectTokens.treeSelectNodeIndent
+      };
+    }
+  };
+};
+export {
+  getTreeSelectOptionStyle
+};

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

@@ -0,0 +1,27 @@
+import { Interpolation } from '@emotion/react';
+import { BaseSelectOptionInterface } from 'components/BaseSelect/BaseSelect.types';
+import { TreeSelectNodeValue } from 'components/TreeSelect/TreeSelect.types';
+import { Theme } from 'themes';
+export interface TreeSelectNodeStyles {
+    wrapper?: () => Interpolation;
+    header?: (theme: Theme) => Interpolation;
+    switcher?: (theme: Theme) => Interpolation;
+    item?: (theme: Theme) => Interpolation;
+    content?: (theme: Theme) => Interpolation;
+    text?: (theme: Theme) => Interpolation;
+    icon?: (theme: Theme) => Interpolation;
+    children?: (theme: Theme) => Interpolation;
+}
+export interface TreeNode extends BaseSelectOptionInterface<TreeSelectNodeValue> {
+    checkable?: boolean;
+    disableCheckbox?: boolean;
+    leaf?: boolean;
+    key: string;
+    selectable?: boolean;
+    children?: TreeNode[];
+}
+export interface TreeSelectOptionProps extends TreeNode {
+    index: number;
+    itemKey: string;
+    styles?: TreeSelectNodeStyles;
+}

package/dist/components/TreeSelect/contexts/treeSelectContext.d.ts

@@ -0,0 +1,14 @@
+import { NodeData, ShowCheckedStrategyType } from '../TreeSelect.types';
+export interface TreeSelectContextShape {
+    nodeDataMap: Map<string, NodeData>;
+    treeCheckable: boolean;
+    showCheckedStrategy: ShowCheckedStrategyType;
+    expandedKeys: string[];
+    loadingKeys: string[];
+    isAsyncLoading: boolean;
+    getCurrentSelectingKey: () => string | null;
+    onSwitcherClick: (key: string) => void;
+    changeElementSize: (index: number, newSize: number) => void;
+    onCheckableClick: (nodeKey: string) => void;
+}
+export declare const treeSelectContext: import('react').Context<TreeSelectContextShape>;

package/dist/components/TreeSelect/contexts/treeSelectContext.js

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+const treeSelectContext = createContext({});
+export {
+  treeSelectContext
+};

package/dist/components/TreeSelect/forStories/dataForExamples.d.ts

@@ -0,0 +1,32 @@
+import { TreeNode } from '../components/TreeSelectOption/TreeSelectOption.types';
+export declare const treeData: ({
+    value: string;
+    title: string;
+    key: string;
+    children: {
+        value: string;
+        title: string;
+        key: string;
+        children: {
+            value: string;
+            title: string;
+            key: string;
+        }[];
+    }[];
+} | {
+    value: string;
+    title: string;
+    key: string;
+    children: {
+        value: string;
+        title: string;
+        key: string;
+    }[];
+})[];
+export declare const baseLoadingData: {
+    value: string;
+    title: string;
+    key: string;
+    children: never[];
+}[];
+export declare const loadData: (node: TreeNode) => Promise<TreeNode[]>;

package/dist/components/TreeSelect/hooks/useAsyncLoading.d.ts

@@ -0,0 +1,8 @@
+import { Dispatch, SetStateAction } from 'react';
+import { TreeNode } from '../components/TreeSelectOption/TreeSelectOption.types';
+import { NodeData } from '../TreeSelect.types';
+export declare const useAsyncLoading: (treeLoadedKeys: string[], nodeDataMap: Map<string, NodeData>, setAsyncTreeData: Dispatch<SetStateAction<TreeNode[]>>, loadData: ((node: TreeNode) => Promise<TreeNode[]>) | undefined) => {
+    loadingKeys: string[];
+    loadedKeys: string[];
+    loadChildrenNodes: (node: TreeNode) => Promise<void>;
+};

package/dist/components/TreeSelect/hooks/useAsyncLoading.js

@@ -0,0 +1,39 @@
+import { useState, useCallback } from "react";
+import { isUndefined } from "lodash-es";
+import { addChildrenNodesToTree } from "../TreeSelect.utils.js";
+const useAsyncLoading = (treeLoadedKeys, nodeDataMap, setAsyncTreeData, loadData) => {
+  const [loadedKeys, setLoadedKeys] = useState(treeLoadedKeys);
+  const [loadingKeys, setLoadingKeys] = useState([]);
+  const addToLoadingKeys = useCallback((key) => {
+    setLoadingKeys((prev) => [...prev, key]);
+  }, []);
+  const removeFromLoadingKey = useCallback((key) => {
+    setLoadingKeys((prev) => prev.filter((item) => item !== key));
+  }, []);
+  const loadChildrenNodes = useCallback(async (node) => {
+    const {
+      key
+    } = node;
+    if (isUndefined(loadData) || loadedKeys.includes(key) || loadingKeys.includes(key)) {
+      return;
+    }
+    try {
+      addToLoadingKeys(node.key);
+      const childrenNodes = await loadData(node);
+      setAsyncTreeData((prev) => addChildrenNodesToTree(prev, childrenNodes, key, nodeDataMap) ?? prev);
+      setLoadedKeys((prev) => [...prev, node.key]);
+    } catch (e) {
+      console.error(e);
+    } finally {
+      removeFromLoadingKey(node.key);
+    }
+  }, [addToLoadingKeys, loadData, loadedKeys, loadingKeys, nodeDataMap, removeFromLoadingKey, setAsyncTreeData]);
+  return {
+    loadingKeys,
+    loadedKeys,
+    loadChildrenNodes
+  };
+};
+export {
+  useAsyncLoading
+};

package/dist/components/TreeSelect/hooks/useElementSizesController.d.ts

@@ -0,0 +1,6 @@
+import { TreeNode } from '../components/TreeSelectOption/TreeSelectOption.types';
+export declare const DEFAULT_ELEMENT_SIZE = 28;
+export declare const useElementSizesController: (treeData: TreeNode[]) => {
+    elementSizes: number[];
+    changeElementSize: (index: number, newSize: number) => void;
+};

package/dist/components/TreeSelect/hooks/useElementSizesController.js

@@ -0,0 +1,21 @@
+import { useState, useCallback } from "react";
+const DEFAULT_ELEMENT_SIZE = 28;
+const useElementSizesController = (treeData) => {
+  const defaultValue = treeData.map(() => DEFAULT_ELEMENT_SIZE);
+  const [elementSizes, setElementSizes] = useState(defaultValue);
+  const changeElementSize = useCallback((index, newSize) => {
+    setElementSizes((prev) => {
+      const newSizes = [...prev];
+      newSizes.splice(index, 1, newSize);
+      return newSizes;
+    });
+  }, []);
+  return {
+    elementSizes,
+    changeElementSize
+  };
+};
+export {
+  DEFAULT_ELEMENT_SIZE,
+  useElementSizesController
+};

package/dist/components/TreeSelect/hooks/useExtendController.d.ts

@@ -0,0 +1,19 @@
+import { TreeNode } from '../components/TreeSelectOption/TreeSelectOption.types';
+interface UseExtendControllerProps {
+    allParentKeys: string[];
+    treeDefaultExpandAll: boolean;
+    treeDefaultExpandedKeys: string[];
+    treeExpandedKeys?: string[];
+    treeNodeMap: Map<string, TreeNode>;
+    onTreeExpand?: (expandedKeys: string[]) => void;
+    onExpandSwitcherClick?: (nodeKey: string) => void;
+    loadChildrenNodes: (node: TreeNode) => Promise<void>;
+    loadData: ((node: TreeNode) => Promise<TreeNode[]>) | undefined;
+    onSearch: ((searchValue: string) => void) | undefined;
+}
+export declare const useExtendController: ({ allParentKeys, treeDefaultExpandAll, treeDefaultExpandedKeys, treeExpandedKeys, treeNodeMap, onTreeExpand, onExpandSwitcherClick, loadChildrenNodes, loadData, onSearch, }: UseExtendControllerProps) => {
+    expandedKeys: string[];
+    onSwitcherClick: (key: string) => void;
+    handleExpandSearch: (searchValue: string) => void;
+};
+export {};

package/dist/components/TreeSelect/hooks/useExtendController.js

@@ -0,0 +1,65 @@
+import { isFunction, isUndefined } from "lodash-es";
+import { useState, useRef, useEffect, useCallback } from "react";
+const useExtendController = ({
+  allParentKeys,
+  treeDefaultExpandAll,
+  treeDefaultExpandedKeys,
+  treeExpandedKeys,
+  treeNodeMap,
+  onTreeExpand,
+  onExpandSwitcherClick,
+  loadChildrenNodes,
+  loadData,
+  onSearch
+}) => {
+  const [isSearching, setIsSearching] = useState(false);
+  const defaultExpand = treeDefaultExpandAll || isSearching ? allParentKeys : treeDefaultExpandedKeys;
+  const [localExpandedKeys, setExpandedKeys] = useState(defaultExpand);
+  const expandedKeys = treeExpandedKeys ?? localExpandedKeys;
+  const hasComponentMount = useRef(false);
+  useEffect(() => {
+    if (!hasComponentMount.current) {
+      hasComponentMount.current = true;
+      return;
+    }
+    onTreeExpand == null ? void 0 : onTreeExpand(localExpandedKeys);
+  }, [localExpandedKeys, onTreeExpand]);
+  const handleExpandSearch = useCallback((searchValue) => {
+    onSearch == null ? void 0 : onSearch(searchValue);
+    if (searchValue.length > 0) {
+      if (!isSearching) {
+        setIsSearching(true);
+      }
+      return;
+    }
+    if (isSearching) {
+      setIsSearching(false);
+    }
+  }, [isSearching, onSearch]);
+  const handleSwitcherClick = useCallback((key) => {
+    onExpandSwitcherClick == null ? void 0 : onExpandSwitcherClick(key);
+    if (isFunction(loadData)) {
+      const node = treeNodeMap.get(key);
+      if (node) {
+        loadChildrenNodes(node);
+      }
+    }
+    if (!isUndefined(treeExpandedKeys)) {
+      return;
+    }
+    setExpandedKeys((prev) => {
+      if (prev.includes(key)) {
+        return prev.filter((item) => item !== key);
+      }
+      return [...prev, key];
+    });
+  }, [loadChildrenNodes, loadData, onExpandSwitcherClick, treeExpandedKeys, treeNodeMap]);
+  return {
+    expandedKeys,
+    onSwitcherClick: handleSwitcherClick,
+    handleExpandSearch
+  };
+};
+export {
+  useExtendController
+};

package/dist/components/TreeSelect/hooks/useKeyControl.d.ts

@@ -0,0 +1,11 @@
+import { KeyboardEvent } from 'react';
+import { TreeNode } from '../components/TreeSelectOption/TreeSelectOption.types';
+export declare const useKeyControl: (treeData: TreeNode[], expandedKeys: string[], treeNodeMap: Map<string, TreeNode>, onDropdownVisibleChange: (() => void) | undefined, onChange: ((selectedKeys: string[], treeNode: TreeNode[]) => void) | undefined, onSearch: ((searchValue: string) => void) | undefined) => {
+    currentSelectingIndex: number;
+    isKeyControl: boolean;
+    onKeyControl: (e: KeyboardEvent) => void;
+    handleDropdownVisibleChange: () => void;
+    handleChange: (selectedKeys: string[], treeNode: TreeNode[]) => void;
+    handleSearch: (searchValue: string) => void;
+    getCurrentSelectingKey: () => string | null;
+};

package/dist/components/TreeSelect/hooks/useKeyControl.js

@@ -0,0 +1,75 @@
+import { useMemo, useState, useCallback } from "react";
+import { isNull } from "lodash-es";
+import { flattenedNodes, getNextOption } from "../TreeSelect.utils.js";
+const useKeyControl = (treeData, expandedKeys, treeNodeMap, onDropdownVisibleChange, onChange, onSearch) => {
+  const flattenedTreeDataKeys = useMemo(() => {
+    return flattenedNodes(treeData, expandedKeys);
+  }, [expandedKeys, treeData]);
+  const [currentStartingPosition, setCurrentStartingPosition] = useState(0);
+  const [currentSelectingIndex, setCurrentSelectingIndex] = useState(0);
+  const [isKeyControl, setIsControl] = useState(false);
+  const getCurrentSelectingKey = useCallback(() => {
+    if (!isKeyControl) {
+      return null;
+    }
+    return flattenedTreeDataKeys[currentSelectingIndex];
+  }, [currentSelectingIndex, flattenedTreeDataKeys, isKeyControl]);
+  const setNextIndex = useCallback((nextItemIndex) => {
+    if (isNull(nextItemIndex)) {
+      return;
+    }
+    setCurrentSelectingIndex(nextItemIndex);
+  }, []);
+  const onKeyControl = useCallback((e) => {
+    if (e.key === "ArrowDown") {
+      if (!isKeyControl) {
+        setIsControl(true);
+        return;
+      }
+      const nextItemIndex = getNextOption(currentSelectingIndex, flattenedTreeDataKeys, treeNodeMap);
+      setNextIndex(nextItemIndex);
+    }
+    if (e.key === "ArrowUp") {
+      if (!isKeyControl) {
+        setIsControl(true);
+        return;
+      }
+      const nextItemIndex = getNextOption(currentSelectingIndex, flattenedTreeDataKeys, treeNodeMap, true);
+      setNextIndex(nextItemIndex);
+    }
+  }, [currentSelectingIndex, flattenedTreeDataKeys, isKeyControl, setNextIndex, treeNodeMap]);
+  const handleSearch = useCallback((searchValue) => {
+    onSearch == null ? void 0 : onSearch(searchValue);
+    setCurrentStartingPosition(0);
+    setCurrentSelectingIndex(0);
+  }, [onSearch]);
+  const handleDropdownVisibleChange = useCallback(() => {
+    onDropdownVisibleChange == null ? void 0 : onDropdownVisibleChange();
+    setIsControl(false);
+    setCurrentSelectingIndex(currentStartingPosition);
+  }, [currentStartingPosition, onDropdownVisibleChange, setCurrentSelectingIndex]);
+  const handleChange = useCallback((selectedKeys, treeNode) => {
+    onChange == null ? void 0 : onChange(selectedKeys, treeNode);
+    const lastSelectedKeyIndex = selectedKeys.length - 1;
+    if (lastSelectedKeyIndex < 0) {
+      setCurrentStartingPosition(0);
+      return;
+    }
+    const lastSelectedKey = selectedKeys[lastSelectedKeyIndex];
+    const lastValueOptionIndex = flattenedTreeDataKeys.findIndex((key) => key === lastSelectedKey);
+    const newStartingIndex = lastValueOptionIndex === -1 ? 0 : lastValueOptionIndex;
+    setCurrentStartingPosition(newStartingIndex);
+  }, [flattenedTreeDataKeys, onChange]);
+  return {
+    currentSelectingIndex,
+    isKeyControl,
+    onKeyControl,
+    handleDropdownVisibleChange,
+    handleChange,
+    handleSearch,
+    getCurrentSelectingKey
+  };
+};
+export {
+  useKeyControl
+};

package/dist/components/TreeSelect/hooks/useTreeCheckable.d.ts

@@ -0,0 +1,6 @@
+import { TreeNode } from '../components/TreeSelectOption/TreeSelectOption.types';
+import { NodeData, ShowCheckedStrategyType } from '../TreeSelect.types';
+export declare const useTreeCheckable: (nodeDataMap: Map<string, NodeData>, treeNodeMap: Map<string, TreeNode>, showCheckedStrategy: ShowCheckedStrategyType, isAsyncLoading: boolean, onDeselect?: ((nodeKey: string) => void) | undefined) => {
+    checkedKeys: string[];
+    onCheckableClick: (nodeKey: string) => void;
+};

package/dist/components/TreeSelect/hooks/useTreeCheckable.js

@@ -0,0 +1,56 @@
+import { getAddedParentKeys, isSelectedByChildStrategy, isSelectedByParentAndAllStrategy } from "../TreeSelect.utils.js";
+import { useState, useCallback } from "react";
+const useTreeCheckable = (nodeDataMap, treeNodeMap, showCheckedStrategy, isAsyncLoading, onDeselect) => {
+  const [checkedKeys, setCheckedKeys] = useState([]);
+  const addNodeKeys = useCallback((key) => {
+    if (Array.isArray(key)) {
+      setCheckedKeys((prev) => {
+        const newValueSet = /* @__PURE__ */ new Set([...prev, ...key]);
+        return Array.from(newValueSet);
+      });
+      return;
+    }
+    setCheckedKeys((prev) => [...prev, key]);
+  }, []);
+  const deleteNodeKeys = useCallback((removeKey) => {
+    if (Array.isArray(removeKey)) {
+      setCheckedKeys((prev) => prev.filter((value) => !removeKey.includes(value)));
+      return;
+    }
+    setCheckedKeys((prev) => prev.filter((key) => key !== removeKey));
+    onDeselect == null ? void 0 : onDeselect(removeKey);
+  }, [onDeselect]);
+  const removeNodes = useCallback((nodeData) => {
+    const removedNodeKeys = [...nodeData.childrenKeys, nodeData.key, ...nodeData.parentKeys];
+    deleteNodeKeys(removedNodeKeys);
+  }, [deleteNodeKeys]);
+  const addNodes = useCallback((nodeData) => {
+    const addedParentKeys = getAddedParentKeys(nodeData.parentKey, nodeData, nodeDataMap, checkedKeys);
+    addNodeKeys([...addedParentKeys, nodeData.key, ...nodeData.childrenKeys]);
+  }, [addNodeKeys, checkedKeys, nodeDataMap]);
+  const handleCheckableClick = useCallback((nodeKey) => {
+    const node = treeNodeMap.get(nodeKey);
+    const nodeData = nodeDataMap.get(nodeKey);
+    if (!nodeData || !node) {
+      return;
+    }
+    const {
+      leaf,
+      children
+    } = node;
+    const isLastNode = leaf || !children || (children == null ? void 0 : children.length) === 0 && !isAsyncLoading;
+    const selected = showCheckedStrategy === "child" ? isSelectedByChildStrategy(node, checkedKeys, isLastNode) : isSelectedByParentAndAllStrategy(node, checkedKeys);
+    if (selected) {
+      removeNodes(nodeData);
+      return;
+    }
+    addNodes(nodeData);
+  }, [addNodes, checkedKeys, isAsyncLoading, nodeDataMap, removeNodes, showCheckedStrategy, treeNodeMap]);
+  return {
+    checkedKeys,
+    onCheckableClick: handleCheckableClick
+  };
+};
+export {
+  useTreeCheckable
+};

package/dist/components/TreeSelect/hooks/useTreeData.d.ts

@@ -0,0 +1,8 @@
+import { TreeNode } from '../components/TreeSelectOption/TreeSelectOption.types';
+import { NodeData } from '../TreeSelect.types';
+export declare const useNodeDataMap: (treeData: TreeNode[]) => {
+    nodeDataMap: Map<string, NodeData>;
+    treeNodeMap: Map<string, TreeNode>;
+    leafChildrenKeys: string[];
+    allParentKeys: string[];
+};

package/dist/components/TreeSelect/hooks/useTreeData.js

@@ -0,0 +1,33 @@
+import { useMemo } from "react";
+import { getNodeData, getAllParentKeys, ROOT_NODE } from "../TreeSelect.utils.js";
+const useNodeDataMap = (treeData) => {
+  const {
+    nodeDataMap,
+    treeNodeMap,
+    leafChildrenKeys,
+    allParentKeys
+  } = useMemo(() => {
+    const treeNodeMap2 = /* @__PURE__ */ new Map();
+    const nodeDataMap2 = /* @__PURE__ */ new Map();
+    const leafChildrenKeys2 = treeData.reduce((acc, treeNode) => {
+      const nodeData = getNodeData(treeNode, ROOT_NODE, [], nodeDataMap2, treeNodeMap2);
+      return [...acc, ...nodeData.leafChildrenKeys];
+    }, []);
+    const allParentKeys2 = getAllParentKeys(treeData);
+    return {
+      nodeDataMap: nodeDataMap2,
+      treeNodeMap: treeNodeMap2,
+      leafChildrenKeys: leafChildrenKeys2,
+      allParentKeys: allParentKeys2
+    };
+  }, [treeData]);
+  return {
+    nodeDataMap,
+    treeNodeMap,
+    leafChildrenKeys,
+    allParentKeys
+  };
+};
+export {
+  useNodeDataMap
+};

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

@@ -0,0 +1,2 @@
+export { TreeSelect } from './TreeSelect';
+export type { TreeSelectProps } from './TreeSelect.types';

package/dist/index.d.ts

@@ -10,13 +10,12 @@ export { Button } from './components/Button';
 export type { ButtonProps } from './components/Button';
 export { Switch } from './components/Switch';
 export type { SwitchProps } from './components/Switch';
-export { Checkbox } from './components/Checkbox';
-export type { CheckboxProps, CheckboxChangeEvent } from './components/Checkbox';
-export type { CheckboxGroupProps } from './components/Checkbox';
+export { Checkbox, isCheckboxChangeEvent } from './components/Checkbox';
+export type { CheckboxProps, CheckboxChangeEvent, CheckboxGroupProps } from './components/Checkbox';
 export { Select } from './components/Select';
 export type { SelectProps } from './components/Select';
 export { type InputProps, Input } from './components/Input';
-export { type InputNumberProps, InputNumber } from './components/InputNumber';
+export { type InputNumberProps, InputNumber, inputNumberWrapperClassName, } from './components/InputNumber';
 export { type RadioChangeEvent, type RadioGroupProps, type RadioProps, Radio, } from './components/Radio';
 export { Alert } from './components/Alert';
 export type { AlertProps } from './components/Alert';
@@ -44,3 +43,5 @@ export { ConfigProvider, useConfig, type Locale } from './components/ConfigProvi
 export type { PickerLocale, RangePickerProps } from './components/InternalPicker';
 export { type FormProps, type FormItemProps, Form } from './components/Form';
 export { type PopconfirmProps, Popconfirm } from './components/Popconfirm';
+export { TreeSelect } from './components/TreeSelect';
+export type { TreeSelectProps } from './components/TreeSelect';

package/dist/index.js

@@ -7,9 +7,11 @@ import { useTheme } from "./hooks/useTheme/useTheme.js";
 import { LoadingOutlined } from "./icons/icons/LoadingOutlined.js";
 import { Button } from "./components/Button/Button.js";
 import { Switch } from "./components/Switch/Switch.js";
+import { isCheckboxChangeEvent } from "./components/Checkbox/Checkbox.utils.js";
 import { Select } from "./components/Select/Select.js";
 import { Input } from "./components/Input/Input.js";
 import { InputNumber } from "./components/InputNumber/InputNumber.js";
+import { inputNumberWrapperClassName } from "./components/InputNumber/InputNumber.styles.js";
 import { Radio } from "./components/Radio/Radio.js";
 import { Alert } from "./components/Alert/Alert.js";
 import { Tooltip } from "./components/Tooltip/Tooltip.js";
@@ -29,6 +31,7 @@ import { ConfigProvider } from "./components/ConfigProvider/ConfigProvider.js";
 import { useConfig } from "./components/ConfigProvider/hooks/useConfig/useConfig.js";
 import { Form } from "./components/Form/Form.js";
 import { Popconfirm } from "./components/Popconfirm/Popconfirm.js";
+import { TreeSelect } from "./components/TreeSelect/TreeSelect.js";
 export {
   Alert,
   Avatar,
@@ -53,8 +56,11 @@ export {
   ThemeProvider,
   TimePicker,
   Tooltip,
+  TreeSelect,
   Upload,
   avatarColors,
+  inputNumberWrapperClassName,
+  isCheckboxChangeEvent,
   message,
   messagesHolder,
   themeMap,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@infomaximum/ui-kit",
   "license": "Apache-2.0",
-  "version": "0.12.11",
+  "version": "0.13.0",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/dist/components/Select/components/SelectOptionList/SelectOptionList.d.ts

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