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

package/dist/Tree/Tree.d.ts

@@ -0,0 +1,126 @@
+import React, { Component, Ref } from 'react';
+import DirectoryTree from './DirectoryTree';
+import RcTree, { TreeProps as RcTreeProps } from './RCTree';
+import TreeNode from './TreeNode';
+import { DataNode, Key } from './typings';
+export interface AntdTreeNodeAttribute {
+    eventKey: string;
+    prefixCls: string;
+    className: string;
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    children: React.ReactElement;
+    title: React.ReactElement;
+    pos: string;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+    isLeaf: boolean;
+    selectable: boolean;
+    disabled: boolean;
+    disableCheckbox: boolean;
+}
+export interface AntTreeNodeProps {
+    className?: string;
+    checkable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    title?: string | React.ReactElement;
+    key?: Key;
+    eventKey?: string;
+    isLeaf?: boolean;
+    checked?: boolean;
+    expanded?: boolean;
+    loading?: boolean;
+    selected?: boolean;
+    selectable?: boolean;
+    icon?: ((treeNode: AntdTreeNodeAttribute) => React.ReactElement) | React.ReactElement;
+    children?: React.ReactElement;
+    [customProp: string]: any;
+}
+export type AntTreeNode = Component<AntTreeNodeProps, {}>;
+export interface AntTreeNodeBaseEvent {
+    node: AntTreeNode;
+    nativeEvent: MouseEvent;
+}
+export interface AntTreeNodeCheckedEvent extends AntTreeNodeBaseEvent {
+    event: 'check';
+    checked?: boolean;
+    checkedNodes?: AntTreeNode[];
+}
+export interface AntTreeNodeSelectedEvent extends AntTreeNodeBaseEvent {
+    event: 'select';
+    selected?: boolean;
+    selectedNodes?: DataNode[];
+}
+export interface AntTreeNodeExpandedEvent extends AntTreeNodeBaseEvent {
+    expanded?: boolean;
+}
+export interface AntTreeNodeMouseEvent {
+    node: AntTreeNode;
+    event: any;
+}
+export interface AntTreeNodeDragEnterEvent extends AntTreeNodeMouseEvent {
+    expandedKeys: Key[];
+}
+export interface AntTreeNodeDropEvent {
+    node: AntTreeNode;
+    dragNode: AntTreeNode;
+    dragNodesKeys: Key[];
+    dropPosition: number;
+    dropToGap?: boolean;
+    event: React.MouseEventHandler<HTMLElement>;
+}
+export type TreeNodeNormal = DataNode;
+type DraggableFn = (node: AntTreeNode) => boolean;
+interface DraggableConfig {
+    icon?: React.ReactElement | false;
+    nodeDraggable?: DraggableFn;
+}
+export interface TreeProps<T> extends Omit<RcTreeProps<T>, 'prefixCls' | 'showLine' | 'direction' | 'draggable'> {
+    showLine?: boolean | {
+        showLeafIcon: boolean;
+    };
+    className?: string;
+    multiple?: boolean;
+    autoExpandParent?: boolean;
+    checkStrictly?: boolean;
+    checkable?: boolean;
+    disabled?: boolean;
+    defaultExpandAll?: boolean;
+    defaultExpandParent?: boolean;
+    defaultExpandedKeys?: Key[];
+    expandedKeys?: Key[];
+    checkedKeys?: Key[] | {
+        checked: Key[];
+        halfChecked: Key[];
+    };
+    defaultCheckedKeys?: Key[];
+    selectedKeys?: Key[];
+    defaultSelectedKeys?: Key[];
+    selectable?: boolean;
+    filterAntTreeNode?: (node: AntTreeNode) => boolean;
+    loadedKeys?: Key[];
+    draggable?: DraggableFn | boolean | DraggableConfig;
+    style?: React.CSSProperties;
+    showIcon?: boolean;
+    icon?: ((nodeProps: AntdTreeNodeAttribute) => React.ReactElement) | React.ReactElement;
+    switcherIcon?: React.ReactElement<any>;
+    prefixCls?: string;
+    children?: React.ReactElement;
+    blockNode?: boolean;
+}
+declare const ForwardTree: <RecordType extends object = any>(props: TreeProps<RecordType> & {
+    ref?: Ref<RcTree>;
+}) => React.ReactElement;
+type InternalTreeType = typeof ForwardTree;
+interface TreeInterface extends InternalTreeType {
+    displayName?: string;
+    defaultProps?: Partial<TreeProps<any>>;
+    TreeNode: typeof TreeNode;
+    DirectoryTree: typeof DirectoryTree;
+}
+declare const Tree: TreeInterface;
+export default Tree;

package/dist/Tree/Tree.js

@@ -0,0 +1,105 @@
+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/Tree.tsx
+var Tree_exports = {};
+__export(Tree_exports, {
+  default: () => Tree_default
+});
+module.exports = __toCommonJS(Tree_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_DirectoryTree = __toESM(require("./DirectoryTree"));
+var import_RCTree = __toESM(require("./RCTree"));
+var import_TreeNode = __toESM(require("./TreeNode"));
+var import_dropIndicator = __toESM(require("./utils/dropIndicator"));
+var import_iconUtil = __toESM(require("./utils/iconUtil"));
+var import_motion = __toESM(require("./utils/motion"));
+function InternalTree(props, ref) {
+  const { prefixCls = "r-tree", className, showIcon, showLine, switcherIcon, blockNode, children, checkable, selectable, draggable } = props;
+  const newProps = {
+    ...props,
+    showLine: Boolean(showLine),
+    dropIndicatorRender: import_dropIndicator.default
+  };
+  const draggableConfig = (0, import_react.useMemo)(() => {
+    if (!draggable) {
+      return false;
+    }
+    let mergedDraggable = {};
+    switch (typeof draggable) {
+      case "function":
+        mergedDraggable.nodeDraggable = draggable;
+        break;
+      case "object":
+        mergedDraggable = { ...draggable };
+        break;
+      default:
+    }
+    return mergedDraggable;
+  }, [draggable]);
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_RCTree.default,
+    {
+      itemHeight: props.itemHeight,
+      ref,
+      virtual: props.virtual,
+      ...newProps,
+      prefixCls,
+      className: (0, import_classnames.default)(
+        {
+          [`${prefixCls}-icon-hide`]: !showIcon,
+          [`${prefixCls}-block-node`]: blockNode,
+          [`${prefixCls}-unselectable`]: !selectable
+        },
+        className
+      ),
+      checkable: checkable ? /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-checkbox-inner` }) : checkable,
+      selectable,
+      switcherIcon: (nodeProps) => (0, import_iconUtil.default)(prefixCls, switcherIcon, showLine, nodeProps),
+      draggable: draggableConfig
+    },
+    children
+  );
+}
+var ForwardTree = (0, import_react.forwardRef)(InternalTree);
+var Tree = ForwardTree;
+Tree.TreeNode = import_TreeNode.default;
+Tree.DirectoryTree = import_DirectoryTree.default;
+Tree.defaultProps = {
+  checkable: false,
+  selectable: true,
+  showIcon: false,
+  motion: {
+    ...import_motion.default,
+    motionAppear: false
+  },
+  blockNode: false,
+  itemHeight: 20
+};
+var Tree_default = Tree;

package/dist/Tree/TreeNode.d.ts

@@ -0,0 +1,83 @@
+import React, { Component, FC, Ref } from 'react';
+import { TreeContextProps } from './contextTypes';
+import { BasicDataNode, DataNode, IconType, Key } from './typings';
+export interface TreeNodeProps<TreeDataType extends BasicDataNode = DataNode> {
+    eventKey?: Key;
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    expanded?: boolean;
+    selected?: boolean;
+    checked?: boolean;
+    loaded?: boolean;
+    loading?: boolean;
+    halfChecked?: boolean;
+    title?: string | React.ReactElement<any> | ((data: TreeDataType) => string | React.ReactElement);
+    dragOver?: boolean;
+    dragOverGapTop?: boolean;
+    dragOverGapBottom?: boolean;
+    pos?: string;
+    domRef?: Ref<HTMLDivElement>;
+    data?: TreeDataType;
+    isStart?: boolean[];
+    isEnd?: boolean[];
+    active?: boolean;
+    onMouseMove?: React.MouseEventHandler<HTMLDivElement>;
+    isLeaf?: boolean;
+    checkable?: boolean;
+    selectable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    switcherIcon?: IconType;
+    children?: React.ReactElement;
+}
+export interface InternalTreeNodeProps extends TreeNodeProps {
+    context?: TreeContextProps;
+}
+export interface TreeNodeState {
+    dragNodeHighlight: boolean;
+}
+declare class InternalTreeNode extends Component<InternalTreeNodeProps, TreeNodeState> {
+    state: {
+        dragNodeHighlight: boolean;
+    };
+    selectHandle: HTMLSpanElement;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    onSelectorClick: (e: React.MouseEvent<HTMLSpanElement>) => void;
+    onSelectorDoubleClick: (e: React.MouseEvent<HTMLSpanElement>) => void;
+    onSelect: (e: React.MouseEvent<HTMLSpanElement>) => void;
+    onCheck: (e: React.MouseEvent<HTMLSpanElement>) => void;
+    onMouseEnter: (e: React.MouseEvent<HTMLSpanElement>) => void;
+    onMouseLeave: (e: React.MouseEvent<HTMLSpanElement>) => void;
+    onContextMenu: (e: React.MouseEvent<HTMLSpanElement>) => void;
+    onDragStart: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragEnter: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragOver: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragLeave: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragEnd: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDrop: (e: React.DragEvent<HTMLDivElement>) => void;
+    onExpand: (e: React.MouseEvent<HTMLDivElement>) => void;
+    setSelectHandle: (node: any) => void;
+    getNodeState: () => "close" | "open";
+    hasChildren: () => boolean;
+    isLeaf: () => boolean;
+    isDisabled: () => boolean;
+    isCheckable: () => boolean | React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    syncLoadData: (props: any) => void;
+    isSelectable(): boolean;
+    isDraggable: () => boolean;
+    renderDragHandler: () => React.JSX.Element;
+    renderSwitcherIconDom: (isLeaf: boolean) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | import("../Icon").IconName;
+    renderSwitcher: () => React.JSX.Element;
+    renderCheckbox: () => React.JSX.Element;
+    renderIcon: () => React.JSX.Element;
+    renderUserIcon: (currentIcon: IconType) => React.JSX.Element;
+    renderSelector: () => React.JSX.Element;
+    renderDropIndicator: () => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    render(): React.JSX.Element;
+}
+declare const ContextTreeNode: FC<TreeNodeProps>;
+export { InternalTreeNode };
+export default ContextTreeNode;