@rainbow-oh/yee-c 0.6.4 → 0.8.0

package/dist/cjs/Selector/selector.js

@@ -98,6 +98,7 @@ var Selector = import_react.default.forwardRef(
       disabled,
       options = [],
       selectedKeys,
+      looseMatch = false,
       orphanClassName,
       orphanStyle,
       allowClear = true,
@@ -123,6 +124,7 @@ var Selector = import_react.default.forwardRef(
       "disabled",
       "options",
       "selectedKeys",
+      "looseMatch",
       "orphanClassName",
       "orphanStyle",
       "allowClear",
@@ -149,7 +151,7 @@ var Selector = import_react.default.forwardRef(
         return [];
       }
       return selectedKeys.map((key) => {
-        const opt = options.find((o) => o.value === key);
+        const opt = looseMatch ? options.find((o) => String(o.value) === String(key)) : options.find((o) => o.value === key);
         if (opt) {
           return __spreadProps(__spreadValues({}, opt), {
             children: typeof optionLabelProp === "function" ? optionLabelProp(opt) : opt[optionLabelProp],
@@ -163,7 +165,7 @@ var Selector = import_react.default.forwardRef(
           _orphan: true
         };
       });
-    }, [options, selectedKeys, optionLabelProp]);
+    }, [options, selectedKeys, optionLabelProp, looseMatch]);
     const handleClick = () => {
       if (inputRef.current && !disabled) {
         inputRef.current.focus();
@@ -247,7 +249,7 @@ var Selector = import_react.default.forwardRef(
         );
       }
       const key = selectedKeys.length ? selectedKeys[0] : "";
-      const opt = Array.isArray(options) ? options.find((opt2) => opt2.value === key) : null;
+      const opt = Array.isArray(options) ? looseMatch ? options.find((opt2) => String(opt2.value) === String(key)) : options.find((opt2) => opt2.value === key) : null;
       const isOrphan = !opt && key !== "";
       const label = opt ? typeof optionLabelProp === "function" ? optionLabelProp(opt) : opt[optionLabelProp] : isOrphan ? String(key) : null;
       return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, renderSearch(), label && /* @__PURE__ */ import_react.default.createElement(

package/dist/cjs/Table/hooks/useColumns.js

@@ -76,7 +76,7 @@ function useColumns({
     const tree = (0, import_header.injectSelectionExpand)(base, rowSelection, expandable);
     const leaves = (0, import_header.flattenLeafColumns)(tree);
     const wraped = (0, import_util.handleColumns)(leaves);
-    const rows = (0, import_header.parseHeaderRows)(tree);
+    const rows = (0, import_header.parseHeaderRows)(tree, wraped);
     return { wrapedColumns: wraped, headerRows: rows };
   }, [childColumns, columns, shouldRenderSelection, shouldRenderExpand]);
   return {

package/dist/cjs/Table/interface.d.ts

@@ -498,7 +498,7 @@ export interface TableProps extends FooterProps, Omit<HeaderProps, 'pageData'>,
     /**
      * Row class name, unlike classNames, this prop can be set dynamically via a function
      */
-    rowClassName?: (record: object) => string | undefined;
+    rowClassName?: (record: Record<string, any>) => string | undefined;
     /**
      * Row style, unlike styles, this prop can be set dynamically via a function
      */

package/dist/cjs/Table/style/index.less

@@ -49,6 +49,12 @@
           background-color: var(--yee-table-head-cell-split-line-color, #eee);
         }
       }
+
+      &-fixed-left,
+      &-fixed-right {
+        position: sticky;
+        z-index: 1;
+      }
     }
 
     &-cell {
@@ -84,6 +90,16 @@
     &-wrapper {
       overflow: auto;
       width: 100%;
+
+      &-scroll-left @{pls}-cell-fixed-left-last {
+        box-shadow: 6px 0 6px -4px
+          var(--yee-table-fixed-left-after-bs-color);
+      }
+
+      &-scroll-right @{pls}-cell-fixed-right-first {
+        box-shadow: -6px 0 6px -4px
+          var(--yee-table-fixed-right-after-bs-color);
+      }
     }
 
     > table {
@@ -101,10 +117,18 @@
     }
   }
 
+  &-row {
+    background-color: var(--yee-table-row-bg-color);
+  }
+
   &-even-row {
     background-color: var(--yee-table-even-row-bg-color);
   }
 
+  &-odd-row {
+    background-color: var(--yee-table-odd-row-bg-color);
+  }
+
   &-column-sorters {
     display: inline-flex;
     align-items: center;
@@ -137,7 +161,7 @@
     &-fixed-left,
     &-fixed-right {
       position: sticky;
-      background-color: inherit;
+      background-color: var(--yee-table-fixed-column-bg-color);
     }
   }
 
@@ -163,17 +187,17 @@
     }
   }
 
-  &-odd-row {
-    > @{pls}-cell {
-      background-color: var(--yee-table-odd-row-bg-color);
-    }
-  }
+  // &-odd-row {
+  //   > @{pls}-cell {
+  //     background-color: var(--yee-table-odd-row-bg-color);
+  //   }
+  // }
 
-  &-even-row {
-    > @{pls}-cell {
-      background-color: var(--yee-table-even-row-bg-color);
-    }
-  }
+  // &-even-row {
+  //   > @{pls}-cell {
+  //     background-color: var(--yee-table-even-row-bg-color);
+  //   }
+  // }
 
   &-footer {
     display: flex;

package/dist/cjs/Table/table.js

@@ -189,6 +189,28 @@ var Table = import_react.default.forwardRef((baseprops, ref) => {
     onChange: onSelectionChange
   } = (0, import_useSelection.default)({ pageData, dataSource, getRowKey, rowSelection, allKeys });
   const prevSortersRef = (0, import_react.useRef)({});
+  const contentWrapperRef = (0, import_react.useRef)(null);
+  const contentRef = (0, import_react.useRef)(null);
+  const [horizontalScroll, setHorizontalScroll] = import_react.default.useState({
+    left: false,
+    right: false
+  });
+  const updateHorizontalScroll = import_react.default.useCallback(() => {
+    const wrapper = contentWrapperRef.current;
+    const content = contentRef.current;
+    if (!wrapper || !content)
+      return;
+    const scrollContainer = content.scrollWidth - content.clientWidth > 1 ? content : wrapper;
+    const maxScrollLeft = scrollContainer.scrollWidth - scrollContainer.clientWidth;
+    const hasHorizontalScroll = maxScrollLeft > 1;
+    const next = {
+      left: hasHorizontalScroll && scrollContainer.scrollLeft > 1,
+      right: hasHorizontalScroll && scrollContainer.scrollLeft < maxScrollLeft - 1
+    };
+    setHorizontalScroll(
+      (current2) => current2.left === next.left && current2.right === next.right ? current2 : next
+    );
+  }, []);
   const onFilter = import_react.default.useCallback(
     (...args) => {
       onFilterInternal(...args);
@@ -229,6 +251,21 @@ var Table = import_react.default.forwardRef((baseprops, ref) => {
       return;
     }
   }, [sorters, current, pageSize, pageData, sortedData, onChange]);
+  (0, import_react.useEffect)(() => {
+    updateHorizontalScroll();
+    const wrapper = contentWrapperRef.current;
+    const content = contentRef.current;
+    if (!wrapper || !content)
+      return void 0;
+    if (typeof ResizeObserver === "undefined") {
+      window.addEventListener("resize", updateHorizontalScroll);
+      return () => window.removeEventListener("resize", updateHorizontalScroll);
+    }
+    const resizeObserver = new ResizeObserver(updateHorizontalScroll);
+    resizeObserver.observe(wrapper);
+    resizeObserver.observe(content);
+    return () => resizeObserver.disconnect();
+  }, [updateHorizontalScroll, wrapedColumns, pageData, scroll == null ? void 0 : scroll.x]);
   const renderHeader = () => {
     return /* @__PURE__ */ import_react.default.createElement(
       import_header.default,
@@ -305,17 +342,30 @@ var Table = import_react.default.forwardRef((baseprops, ref) => {
       },
       /* @__PURE__ */ import_react.default.createElement("table", __spreadValues({}, tableProps), /* @__PURE__ */ import_react.default.createElement(import_col_group.default, { columns: wrapedColumns }), renderTHeader(), renderTBody(), renderTFooter())
     );
-    return /* @__PURE__ */ import_react.default.createElement("div", { className: `${prefixCls}-content-wrapper` }, /* @__PURE__ */ import_react.default.createElement(
+    return /* @__PURE__ */ import_react.default.createElement(
       "div",
       {
-        className: (0, import_clsx.default)(`${prefixCls}-content`, {
-          [`${prefixCls}-${size}-size`]: size,
-          [`${prefixCls}-fixed-header`]: scroll == null ? void 0 : scroll.y
+        ref: contentWrapperRef,
+        className: (0, import_clsx.default)(`${prefixCls}-content-wrapper`, {
+          [`${prefixCls}-content-wrapper-scroll-left`]: horizontalScroll.left,
+          [`${prefixCls}-content-wrapper-scroll-right`]: horizontalScroll.right
         }),
-        style: { height: scroll == null ? void 0 : scroll.y, width: scroll == null ? void 0 : scroll.x }
+        onScroll: updateHorizontalScroll
       },
-      table2
-    ));
+      /* @__PURE__ */ import_react.default.createElement(
+        "div",
+        {
+          ref: contentRef,
+          className: (0, import_clsx.default)(`${prefixCls}-content`, {
+            [`${prefixCls}-${size}-size`]: size,
+            [`${prefixCls}-fixed-header`]: scroll == null ? void 0 : scroll.y
+          }),
+          style: { height: scroll == null ? void 0 : scroll.y, width: scroll == null ? void 0 : scroll.x },
+          onScroll: updateHorizontalScroll
+        },
+        table2
+      )
+    );
   };
   const renderFooter = () => {
     return /* @__PURE__ */ import_react.default.createElement(

package/dist/cjs/Table/tbody/cell.js

@@ -95,7 +95,7 @@ var TableCell = (props) => {
       {
         [`${prefixCls}-cell-fixed-${fixed}`]: fixed,
         [`${prefixCls}-cell-fixed-${fixed}-first`]: isFixedRightFirst,
-        [`${prefixCls}-fixed-${fixed}-last`]: isFixedLeftLast
+        [`${prefixCls}-cell-fixed-${fixed}-last`]: isFixedLeftLast
       },
       className
     );

package/dist/cjs/Table/util/header.d.ts

@@ -11,10 +11,12 @@ export declare function flattenLeafColumns(columns: WrapedColumnProps[], parentF
  *
  * - Pass 1 (DFS): place each column into the row matching its depth; a group's
  *   colSpan equals the sum of its children's colSpans.
+ * - Fixed metadata from the resolved leaf columns is reused by leaf cells and
+ *   aggregated for group cells whose descendants share the same fixed side.
  * - Pass 2: leaf cells (no sub-columns) get rowSpan = rowCount - rowIndex so
  *   they stretch down to the last header row; group cells keep rowSpan = 1.
  */
-export declare function parseHeaderRows(rootColumns: WrapedColumnProps[]): HeaderCell[][];
+export declare function parseHeaderRows(rootColumns: WrapedColumnProps[], resolvedLeafColumns?: WrapedColumnProps[]): HeaderCell[][];
 /**
  * Inject selection / expand columns into the top level of the column tree.
  * `index` is a 1-based position among the top-level columns.

package/dist/cjs/Table/util/header.js

@@ -52,21 +52,48 @@ function flattenLeafColumns(columns, parentFixed) {
     return [...list, __spreadProps(__spreadValues({}, column), { fixed })];
   }, []);
 }
-function parseHeaderRows(rootColumns) {
+function parseHeaderRows(rootColumns, resolvedLeafColumns = flattenLeafColumns(rootColumns)) {
   const rows = [];
+  let leafIndex = 0;
   const fillRowCells = (columns, rowIndex) => {
     rows[rowIndex] = rows[rowIndex] || [];
     let colSpanTotal = 0;
-    columns.filter(Boolean).forEach((column) => {
+    columns.filter(Boolean).forEach((sourceColumn) => {
+      var _a, _b;
+      let column = sourceColumn;
+      const subColumns = sourceColumn.children;
+      const leafStartIndex = leafIndex;
       const cell = {
         column,
         colSpan: 1,
         rowSpan: 1
       };
-      const subColumns = column.children;
       if (subColumns && subColumns.length > 0) {
         cell.colSpan = fillRowCells(subColumns, rowIndex + 1);
         cell.hasSubColumns = true;
+        const groupLeaves = resolvedLeafColumns.slice(
+          leafStartIndex,
+          leafIndex
+        );
+        const fixed = (_a = groupLeaves[0]) == null ? void 0 : _a.fixed;
+        const isFixedGroup = (fixed === "left" || fixed === "right") && groupLeaves.every((leaf) => leaf.fixed === fixed);
+        if (isFixedGroup) {
+          const offsetLeaf = fixed === "left" ? groupLeaves[0] : groupLeaves[groupLeaves.length - 1];
+          const boundaryLeaf = fixed === "left" ? groupLeaves[groupLeaves.length - 1] : groupLeaves[0];
+          column = __spreadProps(__spreadValues({}, sourceColumn), {
+            fixed,
+            style: __spreadProps(__spreadValues({}, sourceColumn.style), {
+              [fixed]: (_b = offsetLeaf.style) == null ? void 0 : _b[fixed]
+            }),
+            isFixedLeftLast: fixed === "left" && boundaryLeaf.isFixedLeftLast,
+            isFixedRightFirst: fixed === "right" && boundaryLeaf.isFixedRightFirst
+          });
+          cell.column = column;
+        }
+      } else {
+        column = resolvedLeafColumns[leafIndex] || sourceColumn;
+        cell.column = column;
+        leafIndex += 1;
       }
       rows[rowIndex].push(cell);
       colSpanTotal += cell.colSpan;

package/dist/cjs/Tree/demo/draggable.js

@@ -78,6 +78,8 @@ var draggable_default = () => {
           {
             dragKey: info.dragKey,
             dropKey: info.dropKey,
+            dragPath: info.dragPath,
+            dropPath: info.dropPath,
             position: info.position
           },
           FIELD_NAMES

package/dist/cjs/Tree/interface.d.ts

@@ -4,13 +4,14 @@ export type DragPosition = 'before' | 'after' | 'inside';
 export type { MoveInfo } from './utils/tree-tools';
 export type TreeNode<T> = {
     /**
-     * uid
+     * Unique internal identifier built from key path joined by '\x00'.
+     * Guaranteed unique even when user-provided `key` values repeat across branches.
      */
     uid: string;
     /**
-     * Unique key
-     * */
-    key: string;
+     * User-provided key (may not be globally unique)
+     */
+    key: string | number;
     /**
      * Display node text
      */
@@ -20,7 +21,7 @@ export type TreeNode<T> = {
      */
     title?: string;
     /**
-     * Child nodes
+     * Child nodes (only present in raw tree; not used in flat list)
      */
     children?: Array<TreeNode<T>>;
     /**
@@ -28,16 +29,16 @@ export type TreeNode<T> = {
      */
     depth: number;
     /**
-     * Parent node key
-     * */
-    pKey: string | null;
+     * Parent node uid (null for root nodes)
+     */
+    pUid: string | null;
     /**
      * Whether this is a leaf node
-     * */
+     */
     isLeaf: boolean;
     /**
      * Whether this is the last node at its level
-     * */
+     */
     isLast: boolean;
     /**
      * Whether disabled
@@ -48,17 +49,17 @@ export type TreeNode<T> = {
      */
     icon?: React.ReactNode | (() => React.ReactNode);
     /**
-     * Ancestor keys
+     * Ancestor keys (user-provided keys, for building uid path)
      */
-    path: string[];
+    path: Array<string | number>;
     /**
-     * Whether to show connecting lines
+     * Whether to show connecting lines at given depth levels
      */
     lines: number[];
     /**
-     * List of child node keys
+     * All descendant uids (collected bottom-up). Used for check/uncheck propagation.
      */
-    childKeys?: Array<string | number>;
+    childUids?: Array<string>;
     /**
      * Original data
      */
@@ -66,6 +67,7 @@ export type TreeNode<T> = {
 };
 export interface TreeNodeProps<T> {
     node: TreeNode<T>;
+    style?: React.CSSProperties;
 }
 export interface TreeProps<T> {
     /**
@@ -89,11 +91,11 @@ export interface TreeProps<T> {
      */
     defaultExpandAll?: boolean;
     /**
-     * Specify which tree nodes to expand by default
+     * Specify which tree nodes to expand by default (user keys)
      */
     defaultExpandedKeys?: string[];
     /**
-     * Controlled expanded tree nodes
+     * Controlled expanded tree nodes (user keys)
      */
     expandedKeys?: string[];
     /**
@@ -124,6 +126,10 @@ export interface TreeProps<T> {
         dropNode: T;
         dragKey: string | number;
         dropKey: string | number;
+        /** Full key path from root to the dragged node (for non-unique key support) */
+        dragPath: Array<string | number>;
+        /** Full key path from root to the drop target (for non-unique key support) */
+        dropPath: Array<string | number>;
         position: DragPosition;
         /** Convenience flag: true when position is 'before' or 'after' */
         dropToGap: boolean;
@@ -164,22 +170,39 @@ export interface TreeProps<T> {
     loadData?: () => void;
     /**
      * Data source
-     * */
+     */
     dataSource?: Array<T> | T;
     /**
-     * Checked tree nodes (controlled)
+     * Enable virtual scrolling for large datasets.
+     * Requires `height` to be set.
+     * @default false
+     */
+    virtual?: boolean;
+    /**
+     * Height of the scrollable container in pixels.
+     * Required when `virtual` is true.
+     */
+    height?: number;
+    /**
+     * Fixed height of each tree node row in pixels.
+     * Used for virtual scroll calculation.
+     * @default 28
+     */
+    itemHeight?: number;
+    /**
+     * Checked tree nodes (controlled, user keys)
      */
     checkedKeys?: Array<string | number>;
     /**
-     * Checked tree nodes (uncontrolled)
+     * Checked tree nodes (uncontrolled, user keys)
      */
     defaultCheckedKeys?: Array<string | number>;
     /**
-     * Set selected tree nodes, set multiple to true for multi-select
+     * Set selected tree nodes, set multiple to true for multi-select (user keys)
      */
     selectedKeys?: Array<string | number>;
     /**
-     * Set default selected tree nodes, set multiple to true for multi-select
+     * Set default selected tree nodes (user keys)
      */
     defaultSelectedKeys?: Array<string | number>;
     /**
@@ -204,6 +227,6 @@ export interface TreeProps<T> {
     onExpand?: (expandedKeys: Array<string | number>, params: {
         expanded: boolean;
         expandedNodes: T[];
-        node: T[];
+        node: T;
     }) => void;
 }

package/dist/cjs/Tree/tree-node.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
 import type { TreeNodeProps } from './interface';
 import './style/index.less';
-declare const Node: <T extends Record<string, unknown> = any>(props: TreeNodeProps<T>) => React.JSX.Element | null;
+declare const Node: <T extends Record<string, unknown> = any>(props: TreeNodeProps<T>) => React.JSX.Element;
 export default Node;

package/dist/cjs/Tree/tree-node.js

@@ -54,12 +54,11 @@ var import_Checkbox = __toESM(require("../Checkbox"));
 var import_tree = require("./tree");
 var import_style = require("./style/index.less");
 var Node = (props) => {
-  const { node } = props;
+  const { node, style: nodeStyle } = props;
   const {
-    key,
+    uid,
     isLeaf,
     isLast,
-    path,
     label,
     title,
     disabled,
@@ -74,12 +73,13 @@ var Node = (props) => {
     showIcon,
     icon: contextIcon,
     showLine,
-    selectedKeys,
-    checkedKeys,
-    expandedKeys,
+    selectedUids,
+    checkedUids,
+    indeterminateUids,
+    expandedUids,
     switcherIcon,
     draggable,
-    draggingKey,
+    draggingUid,
     dropState,
     onCheck,
     onSelect,
@@ -89,12 +89,10 @@ var Node = (props) => {
     onNodeDragLeave,
     onNodeDrop
   } = (0, import_react.useContext)(import_tree.TreeContext);
-  const expanded = expandedKeys.includes(key);
-  const checked = checkedKeys.includes(key);
-  const selected = selectedKeys.includes(key);
-  const visible = path.every((p) => expandedKeys.includes(p));
-  if (!visible)
-    return null;
+  const expanded = expandedUids.has(uid);
+  const checked = checkedUids.has(uid);
+  const indeterminate = indeterminateUids.has(uid);
+  const selected = selectedUids.has(uid);
   const renderExpandedIcon = () => {
     const expandedIcon = switcherIcon ? switcherIcon[0] : /* @__PURE__ */ import_react.default.createElement(import_lucide_react.ChevronDown, { strokeWidth: 1 });
     const collapseIcon = switcherIcon ? switcherIcon[1] : /* @__PURE__ */ import_react.default.createElement(import_lucide_react.ChevronRight, { strokeWidth: 1 });
@@ -113,14 +111,22 @@ var Node = (props) => {
         size: "small",
         type: "text",
         icon: expanded ? expandedIcon : collapseIcon,
-        onClick: () => onExpand(key)
+        onClick: () => onExpand(uid)
       }
     ));
   };
   const renderCheckbox = () => {
     if (!checkable)
       return null;
-    return /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-node-checkbox` }, /* @__PURE__ */ import_react.default.createElement(import_Checkbox.default, { value: key, checked, onChange: onCheck }));
+    return /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-node-checkbox` }, /* @__PURE__ */ import_react.default.createElement(
+      import_Checkbox.default,
+      {
+        value: uid,
+        checked,
+        indeterminate,
+        onChange: (e) => onCheck(e, uid)
+      }
+    ));
   };
   const renderLabel = () => {
     const _title = title || (typeof label === "string" ? label : void 0);
@@ -136,7 +142,7 @@ var Node = (props) => {
         type: "text",
         title: _title,
         icon: showIcon ? _icon : void 0,
-        onClick: disabled ? void 0 : () => onSelect(key)
+        onClick: disabled ? void 0 : () => onSelect(uid)
       },
       label
     );
@@ -164,14 +170,14 @@ var Node = (props) => {
       }
     ));
   };
-  const isDropTarget = (dropState == null ? void 0 : dropState.key) === key;
+  const isDropTarget = (dropState == null ? void 0 : dropState.uid) === uid;
   const dropPosition = isDropTarget ? dropState.position : null;
   const dragProps = draggable && !disabled ? {
     draggable: true,
-    onDragStart: (e) => onNodeDragStart(key, e),
-    onDragOver: (e) => onNodeDragOver(key, e),
-    onDragLeave: (e) => onNodeDragLeave(key, e),
-    onDrop: (e) => onNodeDrop(key, e)
+    onDragStart: (e) => onNodeDragStart(uid, e),
+    onDragOver: (e) => onNodeDragOver(uid, e),
+    onDragLeave: (e) => onNodeDragLeave(uid, e),
+    onDrop: (e) => onNodeDrop(uid, e)
   } : {};
   return /* @__PURE__ */ import_react.default.createElement(
     "div",
@@ -180,11 +186,12 @@ var Node = (props) => {
         [`${prefixCls}-node-with-line`]: showLine,
         [`${prefixCls}-leaf-node`]: isLeaf,
         [`${prefixCls}-last-node`]: isLast,
-        [`${prefixCls}-node-dragging`]: draggingKey === key,
+        [`${prefixCls}-node-dragging`]: draggingUid === uid,
         [`${prefixCls}-node-drag-over-before`]: dropPosition === "before",
         [`${prefixCls}-node-drag-over-after`]: dropPosition === "after",
         [`${prefixCls}-node-drag-over-inside`]: dropPosition === "inside"
-      })
+      }),
+      style: nodeStyle
     }, dragProps),
     renderEmptyNodes(depth),
     renderExpandedIcon(),

package/dist/cjs/Tree/tree.d.ts

@@ -2,7 +2,7 @@ import React, { ChangeEvent } from 'react';
 import type { DragPosition, TreeProps } from './interface';
 import './style/index.less';
 type DropState = {
-    key: string | number;
+    uid: string;
     position: DragPosition;
 } | null;
 export declare const TreeContext: React.Context<{
@@ -12,19 +12,20 @@ export declare const TreeContext: React.Context<{
     icon?: React.ReactNode | ((props: any) => React.ReactNode);
     showLine?: boolean | undefined;
     switcherIcon?: [React.ReactNode, React.ReactNode] | undefined;
-    selectedKeys: Array<string | number>;
-    checkedKeys: Array<string | number>;
-    expandedKeys: Array<string | number>;
+    selectedUids: Set<string>;
+    checkedUids: Set<string>;
+    indeterminateUids: Set<string>;
+    expandedUids: Set<string>;
     draggable?: boolean | undefined;
-    draggingKey: string | number | null;
+    draggingUid: string | null;
     dropState: DropState;
-    onCheck: (event: ChangeEvent<HTMLInputElement>) => void;
-    onSelect: (key: string | number) => void;
-    onExpand: (key: string | number) => void;
-    onNodeDragStart: (key: string | number, e: React.DragEvent) => void;
-    onNodeDragOver: (key: string | number, e: React.DragEvent) => void;
-    onNodeDragLeave: (key: string | number, e: React.DragEvent) => void;
-    onNodeDrop: (key: string | number, e: React.DragEvent) => void;
+    onCheck: (event: ChangeEvent<HTMLInputElement>, uid: string) => void;
+    onSelect: (uid: string) => void;
+    onExpand: (uid: string) => void;
+    onNodeDragStart: (uid: string, e: React.DragEvent) => void;
+    onNodeDragOver: (uid: string, e: React.DragEvent) => void;
+    onNodeDragLeave: (uid: string, e: React.DragEvent) => void;
+    onNodeDrop: (uid: string, e: React.DragEvent) => void;
 }>;
 declare const Tree: <T extends Record<string, unknown> = any>(baseprops: TreeProps<T>) => React.JSX.Element;
 export default Tree;