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

package/dist/Tree/TreeNode.js

@@ -0,0 +1,477 @@
+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/TreeNode.tsx
+var TreeNode_exports = {};
+__export(TreeNode_exports, {
+  InternalTreeNode: () => InternalTreeNode,
+  default: () => TreeNode_default
+});
+module.exports = __toCommonJS(TreeNode_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_Checkbox = require("../Checkbox");
+var import_Icon = require("../Icon");
+var import_Indent = __toESM(require("./Indent"));
+var import_contextTypes = require("./contextTypes");
+var import_pickAttrs = __toESM(require("./utils/pickAttrs"));
+var import_treeUtil = require("./utils/treeUtil");
+var ICON_OPEN = "open";
+var ICON_CLOSE = "close";
+var defaultTitle = "---";
+var InternalTreeNode = class extends import_react.Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      dragNodeHighlight: false
+    };
+    this.onSelectorClick = (e) => {
+      const {
+        context: { onNodeClick }
+      } = this.props;
+      onNodeClick(e, (0, import_treeUtil.convertNodePropsToEventData)(this.props));
+      if (this.isSelectable()) {
+        this.onSelect(e);
+      } else {
+        this.onCheck(e);
+      }
+    };
+    this.onSelectorDoubleClick = (e) => {
+      const {
+        context: { onNodeDoubleClick }
+      } = this.props;
+      onNodeDoubleClick(e, (0, import_treeUtil.convertNodePropsToEventData)(this.props));
+    };
+    this.onSelect = (e) => {
+      if (this.isDisabled()) {
+        return;
+      }
+      const {
+        context: { onNodeSelect }
+      } = this.props;
+      e.preventDefault();
+      onNodeSelect(e, (0, import_treeUtil.convertNodePropsToEventData)(this.props));
+    };
+    this.onCheck = (e) => {
+      if (this.isDisabled()) {
+        return;
+      }
+      const { disableCheckbox, checked } = this.props;
+      const {
+        context: { onNodeCheck }
+      } = this.props;
+      if (!this.isCheckable() || disableCheckbox) {
+        return;
+      }
+      e.preventDefault();
+      const targetChecked = !checked;
+      onNodeCheck(e, (0, import_treeUtil.convertNodePropsToEventData)(this.props), targetChecked);
+    };
+    this.onMouseEnter = (e) => {
+      const {
+        context: { onNodeMouseEnter }
+      } = this.props;
+      onNodeMouseEnter(e, (0, import_treeUtil.convertNodePropsToEventData)(this.props));
+    };
+    this.onMouseLeave = (e) => {
+      const {
+        context: { onNodeMouseLeave }
+      } = this.props;
+      onNodeMouseLeave(e, (0, import_treeUtil.convertNodePropsToEventData)(this.props));
+    };
+    this.onContextMenu = (e) => {
+      const {
+        context: { onNodeContextMenu }
+      } = this.props;
+      onNodeContextMenu(e, (0, import_treeUtil.convertNodePropsToEventData)(this.props));
+    };
+    this.onDragStart = (e) => {
+      const {
+        context: { onNodeDragStart }
+      } = this.props;
+      e.stopPropagation();
+      this.setState({
+        dragNodeHighlight: true
+      });
+      onNodeDragStart(e, this);
+      try {
+        e.dataTransfer.setData("text/plain", "");
+      } catch (error) {
+      }
+    };
+    this.onDragEnter = (e) => {
+      const {
+        context: { onNodeDragEnter }
+      } = this.props;
+      e.preventDefault();
+      e.stopPropagation();
+      onNodeDragEnter(e, this);
+    };
+    this.onDragOver = (e) => {
+      const {
+        context: { onNodeDragOver }
+      } = this.props;
+      e.preventDefault();
+      e.stopPropagation();
+      onNodeDragOver(e, this);
+    };
+    this.onDragLeave = (e) => {
+      const {
+        context: { onNodeDragLeave }
+      } = this.props;
+      e.stopPropagation();
+      onNodeDragLeave(e, this);
+    };
+    this.onDragEnd = (e) => {
+      const {
+        context: { onNodeDragEnd }
+      } = this.props;
+      e.stopPropagation();
+      this.setState({
+        dragNodeHighlight: false
+      });
+      onNodeDragEnd(e, this);
+    };
+    this.onDrop = (e) => {
+      const {
+        context: { onNodeDrop }
+      } = this.props;
+      e.preventDefault();
+      e.stopPropagation();
+      this.setState({
+        dragNodeHighlight: false
+      });
+      onNodeDrop(e, this);
+    };
+    // Disabled item still can be switch
+    this.onExpand = (e) => {
+      const {
+        loading,
+        context: { onNodeExpand }
+      } = this.props;
+      if (loading) {
+        return;
+      }
+      onNodeExpand(e, (0, import_treeUtil.convertNodePropsToEventData)(this.props));
+    };
+    // Drag usage
+    this.setSelectHandle = (node) => {
+      this.selectHandle = node;
+    };
+    this.getNodeState = () => {
+      const { expanded } = this.props;
+      if (this.isLeaf()) {
+        return null;
+      }
+      return expanded ? ICON_OPEN : ICON_CLOSE;
+    };
+    this.hasChildren = () => {
+      const { eventKey } = this.props;
+      const {
+        context: { keyEntities }
+      } = this.props;
+      const { children } = keyEntities[eventKey] || {};
+      return !!(children || []).length;
+    };
+    this.isLeaf = () => {
+      const { isLeaf, loaded } = this.props;
+      const {
+        context: { loadData }
+      } = this.props;
+      const hasChildren = this.hasChildren();
+      if (isLeaf === false) {
+        return false;
+      }
+      return isLeaf || !loadData && !hasChildren || loadData && loaded && !hasChildren;
+    };
+    this.isDisabled = () => {
+      const { disabled } = this.props;
+      const {
+        context: { disabled: treeDisabled }
+      } = this.props;
+      return !!(treeDisabled || disabled);
+    };
+    this.isCheckable = () => {
+      const { checkable } = this.props;
+      const {
+        context: { checkable: treeCheckable }
+      } = this.props;
+      if (!treeCheckable || checkable === false) {
+        return false;
+      }
+      return treeCheckable;
+    };
+    // Load data to avoid default expanded tree without data
+    this.syncLoadData = (props) => {
+      const { expanded, loading, loaded } = props;
+      const {
+        context: { loadData, onNodeLoad }
+      } = this.props;
+      if (loading) {
+        return;
+      }
+      if (loadData && expanded && !this.isLeaf()) {
+        if (!this.hasChildren() && !loaded) {
+          onNodeLoad((0, import_treeUtil.convertNodePropsToEventData)(this.props));
+        }
+      }
+    };
+    this.isDraggable = () => {
+      const {
+        data,
+        context: { draggable }
+      } = this.props;
+      return !!(draggable && (!draggable.nodeDraggable || draggable.nodeDraggable(data)));
+    };
+    // ==================== Render: Drag Handler ====================
+    this.renderDragHandler = () => {
+      const {
+        context: { draggable, prefixCls }
+      } = this.props;
+      return (draggable == null ? void 0 : draggable.icon) ? /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-draggable-icon` }, draggable.icon) : null;
+    };
+    // ====================== Render: Switcher ======================
+    this.renderSwitcherIconDom = (isLeaf) => {
+      const { switcherIcon: switcherIconFromProps } = this.props;
+      const {
+        context: { switcherIcon: switcherIconFromCtx }
+      } = this.props;
+      const switcherIcon = switcherIconFromProps || switcherIconFromCtx;
+      if (typeof switcherIcon === "function") {
+        return switcherIcon({ ...this.props, isLeaf });
+      }
+      return switcherIcon;
+    };
+    // Switcher
+    this.renderSwitcher = () => {
+      const { expanded } = this.props;
+      const {
+        context: { prefixCls }
+      } = this.props;
+      if (this.isLeaf()) {
+        const switcherIconDom2 = this.renderSwitcherIconDom(true);
+        return switcherIconDom2 !== false ? /* @__PURE__ */ import_react.default.createElement("span", { className: (0, import_classnames.default)(`${prefixCls}-switcher`, `${prefixCls}-switcher-noop`) }, switcherIconDom2) : null;
+      }
+      const switcherCls = (0, import_classnames.default)(`${prefixCls}-switcher`, `${prefixCls}-switcher_${expanded ? ICON_OPEN : ICON_CLOSE}`);
+      const switcherIconDom = this.renderSwitcherIconDom(false);
+      return switcherIconDom !== false ? /* @__PURE__ */ import_react.default.createElement("span", { onClick: this.onExpand, className: switcherCls }, switcherIconDom) : null;
+    };
+    // ====================== Render: Checkbox ======================
+    // Checkbox
+    this.renderCheckbox = () => {
+      const { checked, halfChecked, disableCheckbox } = this.props;
+      const disabled = this.isDisabled();
+      const checkable = this.isCheckable();
+      if (!checkable) {
+        return null;
+      }
+      const $custom = typeof checkable !== "boolean" ? checkable : null;
+      return (
+        // @ts-ignore
+        /* @__PURE__ */ import_react.default.createElement(import_Checkbox.Checkbox, { checked, indeterminate: !checked && halfChecked, disabled: disabled || disableCheckbox, onChange: (_, e) => this.onCheck(e) }, $custom)
+      );
+    };
+    // ==================== Render: Title + Icon ====================
+    this.renderIcon = () => {
+      const { loading } = this.props;
+      const {
+        context: { prefixCls }
+      } = this.props;
+      return /* @__PURE__ */ import_react.default.createElement("span", { className: (0, import_classnames.default)(`${prefixCls}-iconEle`, `${prefixCls}-icon__${this.getNodeState() || "docu"}`, loading && `${prefixCls}-icon_loading`) });
+    };
+    this.renderUserIcon = (currentIcon) => {
+      if (typeof currentIcon === "function") {
+        return currentIcon(this.props);
+      } else if (typeof currentIcon === "string") {
+        return /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: currentIcon });
+      } else {
+        return currentIcon;
+      }
+    };
+    // Icon + Title
+    this.renderSelector = () => {
+      const { dragNodeHighlight } = this.state;
+      const { title, selected, icon, loading, data } = this.props;
+      const {
+        context: { prefixCls, showIcon, icon: treeIcon, loadData, titleRender }
+      } = this.props;
+      const disabled = this.isDisabled();
+      const wrapClass = `${prefixCls}-node-content-wrapper`;
+      let $icon;
+      if (showIcon) {
+        const currentIcon = icon || treeIcon;
+        $icon = currentIcon ? /* @__PURE__ */ import_react.default.createElement("span", { className: (0, import_classnames.default)(`${prefixCls}-iconEle`, `${prefixCls}-icon__customize`) }, this.renderUserIcon(currentIcon)) : this.renderIcon();
+      } else if (loadData && loading) {
+        $icon = this.renderIcon();
+      }
+      let titleNode;
+      if (typeof title === "function") {
+        titleNode = title(data);
+      } else if (titleRender) {
+        titleNode = titleRender(data);
+      } else {
+        titleNode = title;
+      }
+      const $title = /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-title` }, titleNode);
+      return /* @__PURE__ */ import_react.default.createElement(
+        "span",
+        {
+          ref: this.setSelectHandle,
+          title: typeof title === "string" ? title : "",
+          className: (0, import_classnames.default)(
+            `${wrapClass}`,
+            `${wrapClass}-${this.getNodeState() || "normal"}`,
+            !disabled && (selected || dragNodeHighlight) && `${prefixCls}-node-selected`
+          ),
+          onMouseEnter: this.onMouseEnter,
+          onMouseLeave: this.onMouseLeave,
+          onContextMenu: this.onContextMenu,
+          onClick: this.onSelectorClick,
+          onDoubleClick: this.onSelectorDoubleClick
+        },
+        $icon,
+        $title,
+        this.renderDropIndicator()
+      );
+    };
+    // =================== Render: Drop Indicator ===================
+    this.renderDropIndicator = () => {
+      const { disabled, eventKey } = this.props;
+      const {
+        context: { draggable, dropLevelOffset, dropPosition, prefixCls, indent, dropIndicatorRender, dragOverNodeKey, direction }
+      } = this.props;
+      const rootDraggable = draggable !== false;
+      const showIndicator = !disabled && rootDraggable && dragOverNodeKey === eventKey;
+      return showIndicator ? dropIndicatorRender({ dropPosition, dropLevelOffset, indent, prefixCls, direction }) : null;
+    };
+  }
+  // Isomorphic needn't load data in server side
+  componentDidMount() {
+    this.syncLoadData(this.props);
+  }
+  componentDidUpdate() {
+    this.syncLoadData(this.props);
+  }
+  isSelectable() {
+    const { selectable } = this.props;
+    const {
+      context: { selectable: treeSelectable }
+    } = this.props;
+    if (typeof selectable === "boolean") {
+      return selectable;
+    }
+    return treeSelectable;
+  }
+  // =========================== Render ===========================
+  render() {
+    const {
+      eventKey,
+      className,
+      style,
+      dragOver,
+      dragOverGapTop,
+      dragOverGapBottom,
+      isLeaf,
+      isStart,
+      isEnd,
+      expanded,
+      selected,
+      checked,
+      halfChecked,
+      loading,
+      domRef,
+      active,
+      onMouseMove,
+      selectable,
+      ...otherProps
+    } = this.props;
+    const {
+      context: { prefixCls, filterTreeNode, keyEntities, dropContainerKey, dropTargetKey, draggingNodeKey }
+    } = this.props;
+    const disabled = this.isDisabled();
+    const dataOrAriaAttributeProps = (0, import_pickAttrs.default)(otherProps, { aria: true, data: true });
+    const { level } = keyEntities[eventKey] || {};
+    const isEndNode = isEnd[isEnd.length - 1];
+    const mergedDraggable = this.isDraggable();
+    const draggableWithoutDisabled = !disabled && mergedDraggable;
+    const dragging = draggingNodeKey === eventKey;
+    const ariaSelected = selectable !== void 0 ? { "aria-selected": !!selectable } : void 0;
+    return /* @__PURE__ */ import_react.default.createElement(
+      "div",
+      {
+        ref: domRef,
+        className: (0, import_classnames.default)(className, `${prefixCls}-treenode`, {
+          [`${prefixCls}-treenode-disabled`]: disabled,
+          [`${prefixCls}-treenode-switcher-${expanded ? "open" : "close"}`]: !isLeaf,
+          [`${prefixCls}-treenode-checkbox-checked`]: checked,
+          [`${prefixCls}-treenode-checkbox-indeterminate`]: halfChecked,
+          [`${prefixCls}-treenode-selected`]: selected,
+          [`${prefixCls}-treenode-loading`]: loading,
+          [`${prefixCls}-treenode-active`]: active,
+          [`${prefixCls}-treenode-leaf-last`]: isEndNode,
+          [`${prefixCls}-treenode-draggable`]: draggableWithoutDisabled,
+          dragging,
+          "drop-target": dropTargetKey === eventKey,
+          "drop-container": dropContainerKey === eventKey,
+          "drag-over": !disabled && dragOver,
+          "drag-over-gap-top": !disabled && dragOverGapTop,
+          "drag-over-gap-bottom": !disabled && dragOverGapBottom,
+          "filter-node": filterTreeNode && filterTreeNode((0, import_treeUtil.convertNodePropsToEventData)(this.props))
+        }),
+        style,
+        draggable: draggableWithoutDisabled,
+        "aria-grabbed": dragging,
+        onDragStart: draggableWithoutDisabled ? this.onDragStart : void 0,
+        onDragEnter: mergedDraggable ? this.onDragEnter : void 0,
+        onDragOver: mergedDraggable ? this.onDragOver : void 0,
+        onDragLeave: mergedDraggable ? this.onDragLeave : void 0,
+        onDrop: mergedDraggable ? this.onDrop : void 0,
+        onDragEnd: mergedDraggable ? this.onDragEnd : void 0,
+        onMouseMove,
+        ...ariaSelected,
+        ...dataOrAriaAttributeProps
+      },
+      /* @__PURE__ */ import_react.default.createElement(import_Indent.default, { prefixCls, level, isStart, isEnd }),
+      this.renderDragHandler(),
+      this.renderSwitcher(),
+      this.renderCheckbox(),
+      this.renderSelector()
+    );
+  }
+};
+var ContextTreeNode = (props) => /* @__PURE__ */ import_react.default.createElement(import_contextTypes.TreeContext.Consumer, null, (context) => /* @__PURE__ */ import_react.default.createElement(InternalTreeNode, { ...props, context }));
+ContextTreeNode.displayName = "TreeNode";
+ContextTreeNode.defaultProps = {
+  title: defaultTitle
+};
+ContextTreeNode.isTreeNode = 1;
+var TreeNode_default = ContextTreeNode;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalTreeNode
+});

package/dist/Tree/contextTypes.d.ts

@@ -0,0 +1,59 @@
+import React, { Context } from 'react';
+import { DraggableConfig } from './RCTree';
+import { BasicDataNode, DataEntity, DataNode, Direction, EventDataNode, IconType, Key, NodeInstance } from './typings';
+export type NodeMouseEventParams = {
+    event: React.MouseEvent;
+    node: EventDataNode;
+};
+export type NodeDragEventParams = {
+    event: DragEvent;
+    node: EventDataNode;
+};
+export type NodeMouseEventHandler = (e: React.MouseEvent<HTMLSpanElement>, node: EventDataNode) => void;
+export type NodeDragEventHandler<T = HTMLDivElement, TreeDataType extends BasicDataNode = DataNode> = (e: any, node: NodeInstance<TreeDataType>, outsideTree?: boolean) => void;
+export interface TreeContextProps {
+    prefixCls: string;
+    selectable: boolean;
+    showIcon: boolean;
+    icon: IconType;
+    switcherIcon: IconType;
+    draggable?: DraggableConfig;
+    draggingNodeKey?: Key;
+    checkable: boolean | React.ReactElement;
+    checkStrictly: boolean;
+    disabled: boolean;
+    keyEntities: Record<Key, DataEntity<any>>;
+    dropLevelOffset?: number;
+    dropContainerKey: Key | null;
+    dropTargetKey: Key | null;
+    dropPosition: -1 | 0 | 1 | null;
+    indent: number | null;
+    dropIndicatorRender: (props: {
+        dropPosition: -1 | 0 | 1;
+        dropLevelOffset: number;
+        indent: any;
+        prefixCls: any;
+        direction: Direction;
+    }) => React.ReactElement;
+    dragOverNodeKey: Key | null;
+    direction: Direction;
+    loadData: (treeNode: EventDataNode) => Promise<void>;
+    filterTreeNode: (treeNode: EventDataNode) => boolean;
+    titleRender?: (node: any) => React.ReactElement | string;
+    onNodeClick: NodeMouseEventHandler;
+    onNodeDoubleClick: NodeMouseEventHandler;
+    onNodeExpand: NodeMouseEventHandler;
+    onNodeSelect: NodeMouseEventHandler;
+    onNodeCheck: (e: React.MouseEvent<HTMLSpanElement>, treeNode: EventDataNode, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode) => void;
+    onNodeMouseEnter: NodeMouseEventHandler;
+    onNodeMouseLeave: NodeMouseEventHandler;
+    onNodeContextMenu: NodeMouseEventHandler;
+    onNodeDragStart: NodeDragEventHandler<any, any>;
+    onNodeDragEnter: NodeDragEventHandler<any, any>;
+    onNodeDragOver: NodeDragEventHandler<any, any>;
+    onNodeDragLeave: NodeDragEventHandler<any, any>;
+    onNodeDragEnd: NodeDragEventHandler<any, any>;
+    onNodeDrop: NodeDragEventHandler<any, any>;
+}
+export declare const TreeContext: Context<TreeContextProps | null>;

package/dist/Tree/contextTypes.js

@@ -0,0 +1,30 @@
+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/Tree/contextTypes.ts
+var contextTypes_exports = {};
+__export(contextTypes_exports, {
+  TreeContext: () => TreeContext
+});
+module.exports = __toCommonJS(contextTypes_exports);
+var import_react = require("react");
+var TreeContext = (0, import_react.createContext)(null);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TreeContext
+});

package/dist/Tree/index.d.ts

@@ -0,0 +1,9 @@
+export { default as DirectoryTree } from './DirectoryTree';
+export type { ExpandAction as DirectoryTreeExpandAction, DirectoryTreeProps } from './DirectoryTree';
+export { default as RCTree } from './RCTree';
+export type { CheckInfo, TreeProps } from './RCTree';
+export { default as Tree } from './Tree';
+export type { AntTreeNode, AntTreeNodeCheckedEvent, AntTreeNodeExpandedEvent, AntTreeNodeMouseEvent, AntTreeNodeProps, AntTreeNodeSelectedEvent, AntdTreeNodeAttribute, } from './Tree';
+export { default as TreeNode } from './TreeNode';
+export type { TreeNodeProps } from './TreeNode';
+export type { BasicDataNode, DataNode, EventDataNode, Key } from './typings';

package/dist/Tree/index.js

@@ -0,0 +1,48 @@
+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/index.ts
+var Tree_exports = {};
+__export(Tree_exports, {
+  DirectoryTree: () => import_DirectoryTree.default,
+  RCTree: () => import_RCTree.default,
+  Tree: () => import_Tree.default,
+  TreeNode: () => import_TreeNode.default
+});
+module.exports = __toCommonJS(Tree_exports);
+var import_DirectoryTree = __toESM(require("./DirectoryTree"));
+var import_RCTree = __toESM(require("./RCTree"));
+var import_Tree = __toESM(require("./Tree"));
+var import_TreeNode = __toESM(require("./TreeNode"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DirectoryTree,
+  RCTree,
+  Tree,
+  TreeNode
+});