@qsxy/element-plus-react 1.0.0-next.1

package/dist/Transition/TransitionGroup.js

@@ -0,0 +1,99 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transition/TransitionGroup.tsx
+var TransitionGroup_exports = {};
+__export(TransitionGroup_exports, {
+  default: () => TransitionGroup_default
+});
+module.exports = __toCommonJS(TransitionGroup_exports);
+var import_react = __toESM(require("react"));
+var import_TransitionGroupContext = __toESM(require("./TransitionGroupContext"));
+var import_childMapping = require("./childMapping");
+var values = Object.values || ((obj) => Object.keys(obj).map((k) => obj[k]));
+var defaultProps = {
+  component: "div",
+  childFactory: (child) => child
+};
+var TransitionGroup = class extends import_react.Component {
+  constructor(props, context) {
+    super(props, context);
+    const handleExited = this.handleExited.bind(this);
+    this.state = {
+      contextValue: { isMounting: true },
+      handleExited,
+      firstRender: true
+    };
+  }
+  componentDidMount() {
+    this.mounted = true;
+    this.setState({
+      contextValue: { isMounting: false }
+    });
+  }
+  componentWillUnmount() {
+    this.mounted = false;
+  }
+  static getDerivedStateFromProps(nextProps, { children: prevChildMapping, handleExited, firstRender }) {
+    return {
+      children: firstRender ? (0, import_childMapping.getInitialChildMapping)(nextProps, handleExited) : (0, import_childMapping.getNextChildMapping)(nextProps, prevChildMapping, handleExited),
+      firstRender: false
+    };
+  }
+  // node is `undefined` when user provided `nodeRef` prop
+  handleExited(child, node) {
+    const currentChildMapping = (0, import_childMapping.getChildMapping)(this.props.children);
+    if (child.key in currentChildMapping) {
+      return;
+    }
+    if (child.props.afterLeave) {
+      child.props.afterLeave(node);
+    }
+    if (this.mounted) {
+      this.setState((state) => {
+        const children = { ...state.children };
+        delete children[child.key];
+        return { children };
+      });
+    }
+  }
+  render() {
+    const { component: Component2 = "div", childFactory = (child) => child, ...props } = this.props;
+    const { contextValue } = this.state;
+    const children = values(this.state.children).map(childFactory);
+    delete props.transitionAppear;
+    delete props.enter;
+    delete props.exit;
+    if (Component2 === null) {
+      return /* @__PURE__ */ import_react.default.createElement(import_TransitionGroupContext.default.Provider, { value: contextValue }, children);
+    }
+    return /* @__PURE__ */ import_react.default.createElement(import_TransitionGroupContext.default.Provider, { value: contextValue }, /* @__PURE__ */ import_react.default.createElement(Component2, { ...props }, children));
+  }
+};
+TransitionGroup.defaultProps = defaultProps;
+var TransitionGroup_default = TransitionGroup;

package/dist/Transition/TransitionGroupContext.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const _default: import("react").Context<any>;
+export default _default;

package/dist/Transition/TransitionGroupContext.js

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transition/TransitionGroupContext.ts
+var TransitionGroupContext_exports = {};
+__export(TransitionGroupContext_exports, {
+  default: () => TransitionGroupContext_default
+});
+module.exports = __toCommonJS(TransitionGroupContext_exports);
+var import_react = require("react");
+var TransitionGroupContext_default = (0, import_react.createContext)(null);

package/dist/Transition/childMapping.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function getChildMapping(children: React.ReactElement<any>[] | React.ReactElement<any>, mapFn?: (child: React.ReactElement<any>) => React.ReactNode): any;
+export declare function mergeChildMappings(prev: any, next: any): {};
+export declare function getInitialChildMapping(props: any, afterLeave: any): any;
+export declare function getNextChildMapping(nextProps: any, prevChildMapping: any, afterLeave: any): {};

package/dist/Transition/childMapping.js

@@ -0,0 +1,128 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transition/childMapping.ts
+var childMapping_exports = {};
+__export(childMapping_exports, {
+  getChildMapping: () => getChildMapping,
+  getInitialChildMapping: () => getInitialChildMapping,
+  getNextChildMapping: () => getNextChildMapping,
+  mergeChildMappings: () => mergeChildMappings
+});
+module.exports = __toCommonJS(childMapping_exports);
+var import_react = require("react");
+function getChildMapping(children, mapFn) {
+  const mapper = (child) => mapFn && (0, import_react.isValidElement)(child) ? mapFn(child) : child;
+  const result = /* @__PURE__ */ Object.create(null);
+  if (children) {
+    import_react.Children.map(children, (c) => c).forEach((child) => {
+      result[child.key] = mapper(child);
+    });
+  }
+  return result;
+}
+function mergeChildMappings(prev, next) {
+  prev = prev || {};
+  next = next || {};
+  function getValueForKey(key) {
+    return key in next ? next[key] : prev[key];
+  }
+  const nextKeysPending = /* @__PURE__ */ Object.create(null);
+  let pendingKeys = [];
+  for (const prevKey in prev) {
+    if (prevKey in next) {
+      if (pendingKeys.length) {
+        nextKeysPending[prevKey] = pendingKeys;
+        pendingKeys = [];
+      }
+    } else {
+      pendingKeys.push(prevKey);
+    }
+  }
+  let i;
+  const childMapping = {};
+  for (const nextKey in next) {
+    if (nextKeysPending[nextKey]) {
+      for (i = 0; i < nextKeysPending[nextKey].length; i++) {
+        const pendingNextKey = nextKeysPending[nextKey][i];
+        childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);
+      }
+    }
+    childMapping[nextKey] = getValueForKey(nextKey);
+  }
+  for (i = 0; i < pendingKeys.length; i++) {
+    childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
+  }
+  return childMapping;
+}
+function getProp(child, prop, props) {
+  return props[prop] != null ? props[prop] : child.props[prop];
+}
+function getInitialChildMapping(props, afterLeave) {
+  return getChildMapping(props.children, (child) => {
+    return (0, import_react.cloneElement)(child, {
+      afterLeave: afterLeave.bind(null, child),
+      visible: true,
+      transitionAppear: getProp(child, "transitionAppear", props),
+      enter: getProp(child, "enter", props),
+      exit: getProp(child, "exit", props)
+    });
+  });
+}
+function getNextChildMapping(nextProps, prevChildMapping, afterLeave) {
+  const nextChildMapping = getChildMapping(nextProps.children);
+  const children = mergeChildMappings(prevChildMapping, nextChildMapping);
+  Object.keys(children).forEach((key) => {
+    const child = children[key];
+    if (!(0, import_react.isValidElement)(child)) {
+      return;
+    }
+    const hasPrev = key in prevChildMapping;
+    const hasNext = key in nextChildMapping;
+    const prevChild = prevChildMapping[key];
+    const isLeaving = (0, import_react.isValidElement)(prevChild) && !prevChild.props.visible;
+    if (hasNext && (!hasPrev || isLeaving)) {
+      children[key] = (0, import_react.cloneElement)(child, {
+        // @ts-ignore
+        afterLeave: afterLeave.bind(null, child),
+        visible: true,
+        exit: getProp(child, "exit", nextProps),
+        enter: getProp(child, "enter", nextProps)
+      });
+    } else if (!hasNext && hasPrev && !isLeaving) {
+      children[key] = (0, import_react.cloneElement)(child, { visible: false });
+    } else if (hasNext && hasPrev && (0, import_react.isValidElement)(prevChild)) {
+      children[key] = (0, import_react.cloneElement)(child, {
+        // @ts-ignore
+        afterLeave: afterLeave.bind(null, child),
+        // @ts-ignore
+        visible: prevChild.props.visible,
+        exit: getProp(child, "exit", nextProps),
+        enter: getProp(child, "enter", nextProps)
+      });
+    }
+  });
+  return children;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getChildMapping,
+  getInitialChildMapping,
+  getNextChildMapping,
+  mergeChildMappings
+});

package/dist/Transition/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Transition } from './Transition';
+export type { TransitionProps } from './Transition';
+export { default as TransitionGroup } from './TransitionGroup';
+export type { TransitionGroupProps } from './TransitionGroup';

package/dist/Transition/index.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transition/index.ts
+var Transition_exports = {};
+__export(Transition_exports, {
+  Transition: () => import_Transition.default,
+  TransitionGroup: () => import_TransitionGroup.default
+});
+module.exports = __toCommonJS(Transition_exports);
+var import_Transition = __toESM(require("./Transition"));
+var import_TransitionGroup = __toESM(require("./TransitionGroup"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Transition,
+  TransitionGroup
+});

package/dist/Transition/util.d.ts

@@ -0,0 +1,2 @@
+export declare function getDOMNode(elementOrRef: any): any;
+export declare function getAnimationEnd(): "webkitAnimationEnd" | "animationend";

package/dist/Transition/util.js

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transition/util.ts
+var util_exports = {};
+__export(util_exports, {
+  getAnimationEnd: () => getAnimationEnd,
+  getDOMNode: () => getDOMNode
+});
+module.exports = __toCommonJS(util_exports);
+var import_react_dom = require("react-dom");
+var getRefTarget = (ref) => {
+  return ref && ("current" in ref ? ref.current : ref);
+};
+function getDOMNode(elementOrRef) {
+  const element = (elementOrRef == null ? void 0 : elementOrRef.ref) || (elementOrRef == null ? void 0 : elementOrRef.child) || getRefTarget(elementOrRef);
+  if ((element == null ? void 0 : element.nodeType) && typeof (element == null ? void 0 : element.nodeName) === "string") {
+    return element;
+  }
+  return (0, import_react_dom.findDOMNode)(element);
+}
+function getAnimationEnd() {
+  const style = document.createElement("div").style;
+  if ("webkitAnimation" in style) {
+    return "webkitAnimationEnd";
+  }
+  return "animationend";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAnimationEnd,
+  getDOMNode
+});

package/dist/Tree/DirectoryTree.d.ts

@@ -0,0 +1,22 @@
+import React, { Ref } from 'react';
+import RcTree from './RCTree';
+import { Key } from './typings';
+import { TreeProps } from './Tree';
+export type ExpandAction = false | 'click' | 'doubleClick';
+export interface DirectoryTreeProps<T> extends TreeProps<T> {
+    expandAction?: ExpandAction;
+}
+export interface DirectoryTreeState {
+    expandedKeys?: Key[];
+    selectedKeys?: Key[];
+}
+declare const ForwardDirectoryTree: <RecordType extends object = any>(props: DirectoryTreeProps<RecordType> & {
+    ref?: Ref<RcTree>;
+}) => React.ReactElement;
+type InternalDirectoryTreeType = typeof ForwardDirectoryTree;
+interface DirectoryTreeInterface extends InternalDirectoryTreeType {
+    displayName?: string;
+    defaultProps?: Partial<DirectoryTreeProps<any>>;
+}
+declare const DirectoryTree: DirectoryTreeInterface;
+export default DirectoryTree;

package/dist/Tree/DirectoryTree.js

@@ -0,0 +1,204 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tree/DirectoryTree.tsx
+var DirectoryTree_exports = {};
+__export(DirectoryTree_exports, {
+  default: () => DirectoryTree_default
+});
+module.exports = __toCommonJS(DirectoryTree_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_debounce = __toESM(require("lodash/debounce"));
+var import_react = __toESM(require("react"));
+var import_util = require("./util");
+var import_treeUtil = require("./utils/treeUtil");
+var import_Icon = require("../Icon");
+var import_Tree = __toESM(require("./Tree"));
+var import_dictUtil = require("./utils/dictUtil");
+var hasChildren = (props) => {
+  const { eventKey } = props;
+  const {
+    context: { keyEntities }
+  } = props;
+  const { children } = keyEntities[eventKey] || {};
+  return !!(children || []).length;
+};
+var isLeaf = (props) => {
+  const { loaded } = props;
+  const {
+    context: { loadData }
+  } = props;
+  const _hasChildren = hasChildren(props);
+  if (props.isLeaf === false) {
+    return false;
+  }
+  return props.isLeaf || !loadData && !_hasChildren || loadData && loaded && !_hasChildren;
+};
+function getIcon(props) {
+  const { expanded } = props;
+  const _isLeaf = isLeaf(props);
+  if (_isLeaf) {
+    return /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "file-lines", prefix: "far" });
+  }
+  return expanded ? /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "folder-open", prefix: "far" }) : /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "folder-closed", prefix: "fas" });
+}
+function getTreeData({ treeData, children }) {
+  return treeData || (0, import_treeUtil.convertTreeToData)(children);
+}
+function InternalDirectoryTree({ defaultExpandAll, defaultExpandParent, defaultExpandedKeys, ...props }, ref) {
+  const lastSelectedKey = (0, import_react.useRef)();
+  const cachedSelectedKeys = (0, import_react.useRef)();
+  const treeRef = (0, import_react.createRef)();
+  (0, import_react.useImperativeHandle)(ref, () => treeRef.current);
+  const getInitExpandedKeys = () => {
+    const { keyEntities } = (0, import_treeUtil.convertDataToEntities)(getTreeData(props));
+    let initExpandedKeys;
+    if (defaultExpandAll) {
+      initExpandedKeys = Object.keys(keyEntities);
+    } else if (defaultExpandParent) {
+      initExpandedKeys = (0, import_util.conductExpandParent)(props.expandedKeys || defaultExpandedKeys || [], keyEntities);
+    } else {
+      initExpandedKeys = props.expandedKeys || defaultExpandedKeys;
+    }
+    return initExpandedKeys;
+  };
+  const [selectedKeys, setSelectedKeys] = (0, import_react.useState)(props.selectedKeys || props.defaultSelectedKeys || []);
+  const [expandedKeys, setExpandedKeys] = (0, import_react.useState)(getInitExpandedKeys());
+  (0, import_react.useEffect)(() => {
+    if ("selectedKeys" in props) {
+      setSelectedKeys(props.selectedKeys);
+    }
+  }, [props.selectedKeys]);
+  (0, import_react.useEffect)(() => {
+    if ("expandedKeys" in props) {
+      setExpandedKeys(props.expandedKeys);
+    }
+  }, [props.expandedKeys]);
+  const expandFolderNode = (event, node) => {
+    if (node.isLeaf || event.shiftKey || event.metaKey || event.ctrlKey) {
+      return;
+    }
+    treeRef.current.onNodeExpand(event, node);
+  };
+  const onDebounceExpand = (0, import_debounce.default)(expandFolderNode, 200, {
+    leading: true
+  });
+  const onExpand = (keys, info) => {
+    var _a;
+    if (!("expandedKeys" in props)) {
+      setExpandedKeys(keys);
+    }
+    return (_a = props.onExpand) == null ? void 0 : _a.call(props, keys, info);
+  };
+  const onClick = (event, node) => {
+    var _a;
+    const { expandAction } = props;
+    if (expandAction === "click") {
+      onDebounceExpand(event, node);
+    }
+    (_a = props.onClick) == null ? void 0 : _a.call(props, event, node);
+  };
+  const onDoubleClick = (event, node) => {
+    var _a;
+    const { expandAction } = props;
+    if (expandAction === "doubleClick") {
+      onDebounceExpand(event, node);
+    }
+    (_a = props.onDoubleClick) == null ? void 0 : _a.call(props, event, node);
+  };
+  const onSelect = (keys, event) => {
+    var _a;
+    const { multiple } = props;
+    const { node, nativeEvent } = event;
+    const { key = "" } = node;
+    const treeData = getTreeData(props);
+    const newEvent = {
+      ...event,
+      selected: true
+      // Directory selected always true
+    };
+    const ctrlPick = (nativeEvent == null ? void 0 : nativeEvent.ctrlKey) || (nativeEvent == null ? void 0 : nativeEvent.metaKey);
+    const shiftPick = nativeEvent == null ? void 0 : nativeEvent.shiftKey;
+    let newSelectedKeys;
+    if (multiple && ctrlPick) {
+      newSelectedKeys = keys;
+      lastSelectedKey.current = key;
+      cachedSelectedKeys.current = newSelectedKeys;
+      newEvent.selectedNodes = (0, import_dictUtil.convertDirectoryKeysToNodes)(treeData, newSelectedKeys);
+    } else if (multiple && shiftPick) {
+      newSelectedKeys = Array.from(
+        /* @__PURE__ */ new Set([
+          ...cachedSelectedKeys.current || [],
+          ...(0, import_dictUtil.calcRangeKeys)({
+            treeData,
+            expandedKeys,
+            startKey: key,
+            endKey: lastSelectedKey.current
+          })
+        ])
+      );
+      newEvent.selectedNodes = (0, import_dictUtil.convertDirectoryKeysToNodes)(treeData, newSelectedKeys);
+    } else {
+      newSelectedKeys = [key];
+      lastSelectedKey.current = key;
+      cachedSelectedKeys.current = newSelectedKeys;
+      newEvent.selectedNodes = (0, import_dictUtil.convertDirectoryKeysToNodes)(treeData, newSelectedKeys);
+    }
+    (_a = props.onSelect) == null ? void 0 : _a.call(props, newSelectedKeys, newEvent);
+    if (!("selectedKeys" in props)) {
+      setSelectedKeys(newSelectedKeys);
+    }
+  };
+  const { prefixCls = "r-tree", className, ...otherProps } = props;
+  const connectClassName = (0, import_classnames.default)(`${prefixCls}-directory`, className);
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_Tree.default,
+    {
+      icon: getIcon,
+      ref: treeRef,
+      blockNode: true,
+      ...otherProps,
+      prefixCls,
+      className: connectClassName,
+      expandedKeys,
+      selectedKeys,
+      onSelect,
+      onClick,
+      onDoubleClick,
+      onExpand
+    }
+  );
+}
+var ForwardDirectoryTree = (0, import_react.forwardRef)(InternalDirectoryTree);
+var DirectoryTree = ForwardDirectoryTree;
+DirectoryTree.displayName = "DirectoryTree";
+DirectoryTree.defaultProps = {
+  showIcon: true,
+  expandAction: "doubleClick"
+};
+var DirectoryTree_default = DirectoryTree;

package/dist/Tree/DropIndicator.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export default function DropIndicator({ dropPosition, dropLevelOffset, indent }: {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    indent: number;
+}): React.JSX.Element;

package/dist/Tree/DropIndicator.js

@@ -0,0 +1,59 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tree/DropIndicator.tsx
+var DropIndicator_exports = {};
+__export(DropIndicator_exports, {
+  default: () => DropIndicator
+});
+module.exports = __toCommonJS(DropIndicator_exports);
+var import_react = __toESM(require("react"));
+function DropIndicator({ dropPosition, dropLevelOffset, indent }) {
+  const style = {
+    pointerEvents: "none",
+    position: "absolute",
+    right: 0,
+    backgroundColor: "red",
+    height: 2
+  };
+  switch (dropPosition) {
+    case -1:
+      style.top = 0;
+      style.left = -dropLevelOffset * indent;
+      break;
+    case 1:
+      style.bottom = 0;
+      style.left = -dropLevelOffset * indent;
+      break;
+    case 0:
+      style.bottom = 0;
+      style.left = indent;
+      break;
+  }
+  return /* @__PURE__ */ import_react.default.createElement("div", { style });
+}

package/dist/Tree/Indent.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface IndentProps {
+    prefixCls: string;
+    level: number;
+    isStart: boolean[];
+    isEnd: boolean[];
+}
+declare const _default: React.MemoExoticComponent<({ prefixCls, level, isStart, isEnd }: IndentProps) => React.JSX.Element>;
+export default _default;