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

package/dist/Tree/typings.d.ts

@@ -0,0 +1,78 @@
+import React, { Component } from 'react';
+import { IconName } from '../Icon';
+import { TreeNodeProps } from './TreeNode';
+export { ScrollTo } from '../VirtualList';
+export interface BasicDataNode {
+    checkable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    isLeaf?: boolean;
+    selectable?: boolean;
+    switcherIcon?: IconType;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface DataNode<T = any> extends BasicDataNode {
+    children?: T[];
+    key?: string | number;
+    title?: string | React.ReactElement;
+}
+export interface EventDataNode extends DataNode {
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    loaded: boolean;
+    loading: boolean;
+    halfChecked: boolean;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+    pos: string;
+    active: boolean;
+}
+export type IconType = React.ReactElement | ((props: TreeNodeProps) => React.ReactElement) | IconName;
+export type Key = string | number;
+export type NodeElement = React.ReactElement<TreeNodeProps> & {
+    selectHandle?: HTMLSpanElement;
+    type: {
+        isTreeNode: boolean;
+    };
+};
+export type NodeInstance<TreeDataType extends BasicDataNode = DataNode> = Component<TreeNodeProps<TreeDataType>> & {
+    selectHandle?: HTMLSpanElement;
+};
+export interface Entity {
+    node: NodeElement;
+    index: number;
+    key: Key;
+    pos: string;
+    parent?: Entity;
+    children?: Entity[];
+}
+export interface DataEntity<TreeDataType extends BasicDataNode = DataNode> extends Omit<Entity, 'node' | 'parent' | 'children'> {
+    node: TreeDataType;
+    nodes: TreeDataType[];
+    parent?: DataEntity<TreeDataType>;
+    children?: DataEntity<TreeDataType>[];
+    level: number;
+}
+export interface FlattenNode {
+    parent: FlattenNode | null;
+    children: FlattenNode[];
+    pos: string;
+    data: DataNode;
+    title: React.ReactElement;
+    key: Key;
+    isStart: boolean[];
+    isEnd: boolean[];
+}
+export type GetKey<RecordType> = (record: RecordType, index?: number) => Key;
+export type GetCheckDisabled<RecordType> = (record: RecordType) => boolean;
+export type Direction = 'ltr' | 'rtl' | undefined;
+export interface FieldNames {
+    title?: string;
+    _title?: string[];
+    key?: string;
+    children?: string;
+}

package/dist/Tree/typings.js

@@ -0,0 +1,29 @@
+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/typings.tsx
+var typings_exports = {};
+__export(typings_exports, {
+  ScrollTo: () => import_VirtualList.ScrollTo
+});
+module.exports = __toCommonJS(typings_exports);
+var import_VirtualList = require("../VirtualList");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScrollTo
+});

package/dist/Tree/util.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { ComponentChildren } from '../types/common';
+import { AllowDrop, TreeProps } from './RCTree';
+import { BasicDataNode, DataEntity, DataNode, Direction, FlattenNode, Key, NodeElement, NodeInstance } from './typings';
+export interface Option {
+    keepEmpty?: boolean;
+}
+export declare function toArray(children: ComponentChildren, option?: Option): React.ReactElement[];
+export declare function arrDel(list: Key[], value: Key): Key[];
+export declare function arrAdd(list: Key[], value: Key): Key[];
+export declare function posToArr(pos: string): string[];
+export declare function getPosition(level: string | number, index: number): string;
+export declare function isTreeNode(node: NodeElement): boolean;
+export declare function getDragChildrenKeys<TreeDataType extends BasicDataNode = DataNode>(dragNodeKey: Key, keyEntities: Record<Key, DataEntity<TreeDataType>>): Key[];
+export declare function isLastChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
+export declare function isFirstChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
+export declare function calcDropPosition<TreeDataType extends BasicDataNode = DataNode>(event: React.MouseEvent<HTMLElement>, dragNode: NodeInstance<TreeDataType>, targetNode: NodeInstance<TreeDataType>, indent: number, startMousePosition: {
+    x: number;
+    y: number;
+}, allowDrop: AllowDrop<TreeDataType>, flattenedNodes: FlattenNode[], keyEntities: Record<Key, DataEntity<TreeDataType>>, expandKeys: Key[], direction: Direction): {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    dropTargetKey: Key;
+    dropTargetPos: string;
+    dropContainerKey: Key;
+    dragOverNodeKey: Key;
+    dropAllowed: boolean;
+};
+export declare function calcSelectedKeys(selectedKeys: Key[], props: TreeProps): Key[];
+export declare function convertDataToTree(treeData: DataNode[], processor?: {
+    processProps: (prop: DataNode) => any;
+}): NodeElement[];
+export declare function parseCheckedKeys(keys: Key[] | {
+    checked: Key[];
+    halfChecked: Key[];
+}): any;
+export declare function conductExpandParent(keyList: Key[], keyEntities: Record<Key, DataEntity>): Key[];
+export declare function omit<T extends object, K extends keyof T>(obj: T, fields: K[]): Omit<T, K>;

package/dist/Tree/util.js

@@ -0,0 +1,312 @@
+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/util.tsx
+var util_exports = {};
+__export(util_exports, {
+  arrAdd: () => arrAdd,
+  arrDel: () => arrDel,
+  calcDropPosition: () => calcDropPosition,
+  calcSelectedKeys: () => calcSelectedKeys,
+  conductExpandParent: () => conductExpandParent,
+  convertDataToTree: () => convertDataToTree,
+  getDragChildrenKeys: () => getDragChildrenKeys,
+  getPosition: () => getPosition,
+  isFirstChild: () => isFirstChild,
+  isLastChild: () => isLastChild,
+  isTreeNode: () => isTreeNode,
+  omit: () => omit,
+  parseCheckedKeys: () => parseCheckedKeys,
+  posToArr: () => posToArr,
+  toArray: () => toArray
+});
+module.exports = __toCommonJS(util_exports);
+var import_react = __toESM(require("react"));
+var import_Util = require("../Util");
+var import_TreeNode = __toESM(require("./TreeNode"));
+function toArray(children, option = {}) {
+  let ret = [];
+  import_react.Children.forEach(children, (child) => {
+    if ((child === void 0 || child === null) && !option.keepEmpty) {
+      return;
+    }
+    let nodeType = child == null ? void 0 : child.type;
+    nodeType = (nodeType == null ? void 0 : nodeType.displayName) || nodeType;
+    if (Array.isArray(child)) {
+      ret = ret.concat(toArray(child));
+    } else if (nodeType === "Fragment" && child.props) {
+      ret = ret.concat(toArray(child.props.children, option));
+    } else {
+      ret.push(child);
+    }
+  });
+  return ret;
+}
+function arrDel(list, value) {
+  if (!list) {
+    return [];
+  }
+  const clone = list.slice();
+  const index = clone.indexOf(value);
+  if (index >= 0) {
+    clone.splice(index, 1);
+  }
+  return clone;
+}
+function arrAdd(list, value) {
+  const clone = (list || []).slice();
+  if (clone.indexOf(value) === -1) {
+    clone.push(value);
+  }
+  return clone;
+}
+function posToArr(pos) {
+  return pos.split("-");
+}
+function getPosition(level, index) {
+  return `${level}-${index}`;
+}
+function isTreeNode(node) {
+  return node && node.type && node.type.isTreeNode;
+}
+function getDragChildrenKeys(dragNodeKey, keyEntities) {
+  const dragChildrenKeys = [];
+  const entity = keyEntities[dragNodeKey];
+  function dig(list = []) {
+    list.forEach(({ key, children }) => {
+      dragChildrenKeys.push(key);
+      dig(children);
+    });
+  }
+  dig(entity.children);
+  return dragChildrenKeys;
+}
+function isLastChild(treeNodeEntity) {
+  if (treeNodeEntity.parent) {
+    const posArr = posToArr(treeNodeEntity.pos);
+    return Number(posArr[posArr.length - 1]) === treeNodeEntity.parent.children.length - 1;
+  }
+  return false;
+}
+function isFirstChild(treeNodeEntity) {
+  const posArr = posToArr(treeNodeEntity.pos);
+  return Number(posArr[posArr.length - 1]) === 0;
+}
+function calcDropPosition(event, dragNode, targetNode, indent, startMousePosition, allowDrop, flattenedNodes, keyEntities, expandKeys, direction) {
+  var _a;
+  const { clientX, clientY } = event;
+  const { top, height } = event.target.getBoundingClientRect();
+  const horizontalMouseOffset = (direction === "rtl" ? -1 : 1) * (((startMousePosition == null ? void 0 : startMousePosition.x) || 0) - clientX);
+  const rawDropLevelOffset = (horizontalMouseOffset - 12) / indent;
+  let abstractDropNodeEntity = keyEntities[targetNode.props.eventKey];
+  if (clientY < top + height / 2) {
+    const nodeIndex = flattenedNodes.findIndex((flattenedNode) => flattenedNode.key === abstractDropNodeEntity.key);
+    const prevNodeIndex = nodeIndex <= 0 ? 0 : nodeIndex - 1;
+    const prevNodeKey = flattenedNodes[prevNodeIndex].key;
+    abstractDropNodeEntity = keyEntities[prevNodeKey];
+  }
+  const initialAbstractDropNodeKey = abstractDropNodeEntity.key;
+  const abstractDragOverEntity = abstractDropNodeEntity;
+  const dragOverNodeKey = abstractDropNodeEntity.key;
+  let dropPosition = 0;
+  let dropLevelOffset = 0;
+  if (!expandKeys.includes(initialAbstractDropNodeKey)) {
+    for (let i = 0; i < rawDropLevelOffset; i += 1) {
+      if (isLastChild(abstractDropNodeEntity)) {
+        abstractDropNodeEntity = abstractDropNodeEntity.parent;
+        dropLevelOffset += 1;
+      } else {
+        break;
+      }
+    }
+  }
+  const abstractDragDataNode = dragNode.props.data;
+  const abstractDropDataNode = abstractDropNodeEntity.node;
+  let dropAllowed = true;
+  if (isFirstChild(abstractDropNodeEntity) && abstractDropNodeEntity.level === 0 && clientY < top + height / 2 && allowDrop({
+    dragNode: abstractDragDataNode,
+    dropNode: abstractDropDataNode,
+    dropPosition: -1
+  }) && abstractDropNodeEntity.key === targetNode.props.eventKey) {
+    dropPosition = -1;
+  } else if ((abstractDragOverEntity.children || []).length && expandKeys.includes(dragOverNodeKey)) {
+    if (allowDrop({
+      dragNode: abstractDragDataNode,
+      dropNode: abstractDropDataNode,
+      dropPosition: 0
+    })) {
+      dropPosition = 0;
+    } else {
+      dropAllowed = false;
+    }
+  } else if (dropLevelOffset === 0) {
+    if (rawDropLevelOffset > -1.5) {
+      if (allowDrop({
+        dragNode: abstractDragDataNode,
+        dropNode: abstractDropDataNode,
+        dropPosition: 1
+      })) {
+        dropPosition = 1;
+      } else {
+        dropAllowed = false;
+      }
+    } else {
+      if (allowDrop({
+        dragNode: abstractDragDataNode,
+        dropNode: abstractDropDataNode,
+        dropPosition: 0
+      })) {
+        dropPosition = 0;
+      } else if (allowDrop({
+        dragNode: abstractDragDataNode,
+        dropNode: abstractDropDataNode,
+        dropPosition: 1
+      })) {
+        dropPosition = 1;
+      } else {
+        dropAllowed = false;
+      }
+    }
+  } else {
+    if (allowDrop({
+      dragNode: abstractDragDataNode,
+      dropNode: abstractDropDataNode,
+      dropPosition: 1
+    })) {
+      dropPosition = 1;
+    } else {
+      dropAllowed = false;
+    }
+  }
+  return {
+    dropPosition,
+    dropLevelOffset,
+    dropTargetKey: abstractDropNodeEntity.key,
+    dropTargetPos: abstractDropNodeEntity.pos,
+    dragOverNodeKey,
+    dropContainerKey: dropPosition === 0 ? null : ((_a = abstractDropNodeEntity.parent) == null ? void 0 : _a.key) || null,
+    dropAllowed
+  };
+}
+function calcSelectedKeys(selectedKeys, props) {
+  if (!selectedKeys) {
+    return void 0;
+  }
+  const { multiple } = props;
+  if (multiple) {
+    return selectedKeys.slice();
+  }
+  if (selectedKeys.length) {
+    return [selectedKeys[0]];
+  }
+  return selectedKeys;
+}
+var internalProcessProps = (props) => props;
+function convertDataToTree(treeData, processor) {
+  if (!treeData) {
+    return [];
+  }
+  const { processProps = internalProcessProps } = processor || {};
+  const list = Array.isArray(treeData) ? treeData : [treeData];
+  return list.map(({ children, ...props }) => {
+    const childrenNodes = convertDataToTree(children, processor);
+    return /* @__PURE__ */ import_react.default.createElement(import_TreeNode.default, { key: props.key, ...processProps(props) }, childrenNodes);
+  });
+}
+function parseCheckedKeys(keys) {
+  if (!keys) {
+    return null;
+  }
+  let keyProps;
+  if (Array.isArray(keys)) {
+    keyProps = {
+      checkedKeys: keys,
+      halfCheckedKeys: void 0
+    };
+  } else if (typeof keys === "object") {
+    keyProps = {
+      checkedKeys: keys.checked || void 0,
+      halfCheckedKeys: keys.halfChecked || void 0
+    };
+  } else {
+    (0, import_Util.warning)(false, "`checkedKeys` is not an array or an object");
+    return null;
+  }
+  return keyProps;
+}
+function conductExpandParent(keyList, keyEntities) {
+  const expandedKeys = /* @__PURE__ */ new Set();
+  function conductUp(key) {
+    if (expandedKeys.has(key)) {
+      return;
+    }
+    const entity = keyEntities[key];
+    if (!entity) {
+      return;
+    }
+    expandedKeys.add(key);
+    const { parent, node } = entity;
+    if (node.disabled) {
+      return;
+    }
+    if (parent) {
+      conductUp(parent.key);
+    }
+  }
+  (keyList || []).forEach((key) => {
+    conductUp(key);
+  });
+  return [...expandedKeys];
+}
+function omit(obj, fields) {
+  const clone = { ...obj };
+  if (Array.isArray(fields)) {
+    fields.forEach((key) => {
+      delete clone[key];
+    });
+  }
+  return clone;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  arrAdd,
+  arrDel,
+  calcDropPosition,
+  calcSelectedKeys,
+  conductExpandParent,
+  convertDataToTree,
+  getDragChildrenKeys,
+  getPosition,
+  isFirstChild,
+  isLastChild,
+  isTreeNode,
+  omit,
+  parseCheckedKeys,
+  posToArr,
+  toArray
+});

package/dist/Tree/utils/KeyCode.d.ts

@@ -0,0 +1,110 @@
+declare const KeyCode: {
+    MAC_ENTER: number;
+    BACKSPACE: number;
+    TAB: number;
+    NUM_CENTER: number;
+    ENTER: number;
+    SHIFT: number;
+    CTRL: number;
+    ALT: number;
+    PAUSE: number;
+    CAPS_LOCK: number;
+    ESC: number;
+    SPACE: number;
+    PAGE_UP: number;
+    PAGE_DOWN: number;
+    END: number;
+    HOME: number;
+    LEFT: number;
+    UP: number;
+    RIGHT: number;
+    DOWN: number;
+    PRINT_SCREEN: number;
+    INSERT: number;
+    DELETE: number;
+    ZERO: number;
+    ONE: number;
+    TWO: number;
+    THREE: number;
+    FOUR: number;
+    FIVE: number;
+    SIX: number;
+    SEVEN: number;
+    EIGHT: number;
+    NINE: number;
+    QUESTION_MARK: number;
+    A: number;
+    B: number;
+    C: number;
+    D: number;
+    E: number;
+    F: number;
+    G: number;
+    H: number;
+    I: number;
+    J: number;
+    K: number;
+    L: number;
+    M: number;
+    N: number;
+    O: number;
+    P: number;
+    Q: number;
+    R: number;
+    S: number;
+    T: number;
+    U: number;
+    V: number;
+    W: number;
+    X: number;
+    Y: number;
+    Z: number;
+    META: number;
+    WIN_KEY_RIGHT: number;
+    CONTEXT_MENU: number;
+    NUM_ZERO: number;
+    NUM_ONE: number;
+    NUM_TWO: number;
+    NUM_THREE: number;
+    NUM_FOUR: number;
+    NUM_FIVE: number;
+    NUM_SIX: number;
+    NUM_SEVEN: number;
+    NUM_EIGHT: number;
+    NUM_NINE: number;
+    NUM_MULTIPLY: number;
+    NUM_PLUS: number;
+    NUM_MINUS: number;
+    NUM_PERIOD: number;
+    NUM_DIVISION: number;
+    F1: number;
+    F2: number;
+    F3: number;
+    F4: number;
+    F5: number;
+    F6: number;
+    F7: number;
+    F8: number;
+    F9: number;
+    F10: number;
+    F11: number;
+    F12: number;
+    NUMLOCK: number;
+    SEMICOLON: number;
+    DASH: number;
+    EQUALS: number;
+    COMMA: number;
+    PERIOD: number;
+    SLASH: number;
+    APOSTROPHE: number;
+    SINGLE_QUOTE: number;
+    OPEN_SQUARE_BRACKET: number;
+    BACKSLASH: number;
+    CLOSE_SQUARE_BRACKET: number;
+    WIN_KEY: number;
+    MAC_FF_META: number;
+    WIN_IME: number;
+    isTextModifyingKeyEvent: (e: KeyboardEvent) => boolean;
+    isCharacterKey: (keyCode: number) => boolean;
+};
+export default KeyCode;