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

package/dist/Tree/Indent.js

@@ -0,0 +1,56 @@
+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/Indent.tsx
+var Indent_exports = {};
+__export(Indent_exports, {
+  default: () => Indent_default
+});
+module.exports = __toCommonJS(Indent_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var Indent = ({ prefixCls, level, isStart, isEnd }) => {
+  const baseClassName = `${prefixCls}-indent-unit`;
+  const list = [];
+  for (let i = 0; i < level; i += 1) {
+    list.push(
+      /* @__PURE__ */ import_react.default.createElement(
+        "span",
+        {
+          key: i,
+          className: (0, import_classnames.default)(baseClassName, {
+            [`${baseClassName}-start`]: isStart[i],
+            [`${baseClassName}-end`]: isEnd[i]
+          })
+        }
+      )
+    );
+  }
+  return /* @__PURE__ */ import_react.default.createElement("span", { "aria-hidden": "true", className: `${prefixCls}-indent` }, list);
+};
+var Indent_default = (0, import_react.memo)(Indent);

package/dist/Tree/MotionTreeNode.d.ts

@@ -0,0 +1,15 @@
+import { FC } from 'react';
+import { TreeNodeProps } from './TreeNode';
+import { FlattenNode } from './typings';
+import { TreeNodeRequiredProps } from './utils/treeUtil';
+interface MotionTreeNodeProps extends Omit<TreeNodeProps, 'domRef'> {
+    active: boolean;
+    motion?: any;
+    motionNodes?: FlattenNode[];
+    onMotionStart: () => void;
+    onMotionEnd: () => void;
+    motionType?: 'show' | 'hide';
+    treeNodeRequiredProps: TreeNodeRequiredProps;
+}
+declare const MotionTreeNode: FC<MotionTreeNodeProps>;
+export default MotionTreeNode;

package/dist/Tree/MotionTreeNode.js

@@ -0,0 +1,109 @@
+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/MotionTreeNode.tsx
+var MotionTreeNode_exports = {};
+__export(MotionTreeNode_exports, {
+  default: () => MotionTreeNode_default
+});
+module.exports = __toCommonJS(MotionTreeNode_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_react = __toESM(require("react"));
+var import_Transition = require("../Transition");
+var import_TreeNode = __toESM(require("./TreeNode"));
+var import_contextTypes = require("./contextTypes");
+var import_treeUtil = require("./utils/treeUtil");
+var MotionTreeNode = (0, import_react.forwardRef)(
+  ({
+    className,
+    style,
+    motion,
+    motionNodes,
+    motionType,
+    onMotionStart: onOriginMotionStart,
+    onMotionEnd: onOriginMotionEnd,
+    active,
+    treeNodeRequiredProps,
+    ...props
+  }, ref) => {
+    const [visible, setVisible] = (0, import_react.useState)(true);
+    const { prefixCls } = (0, import_react.useContext)(import_contextTypes.TreeContext);
+    const motionedRef = (0, import_react.useRef)(false);
+    const onMotionEnd = () => {
+      if (!motionedRef.current) {
+        onOriginMotionEnd();
+      }
+      motionedRef.current = true;
+    };
+    (0, import_react.useEffect)(() => {
+      if (motionNodes && motionType === "hide" && visible) {
+        setVisible(false);
+      }
+    }, [motionNodes]);
+    (0, import_react.useEffect)(() => {
+      if (motionNodes) {
+        onOriginMotionStart();
+      }
+      return () => {
+        if (motionNodes) {
+          onMotionEnd();
+        }
+      };
+    }, []);
+    if (motionNodes) {
+      return /* @__PURE__ */ import_react.default.createElement(import_Transition.Transition, { ref, visible, ...motion, transitionAppear: motionType === "show", afterEnter: onMotionEnd, afterLeave: onMotionEnd }, ({ className: motionClassName, style: motionStyle }, motionRef) => /* @__PURE__ */ import_react.default.createElement("div", { ref: motionRef, className: (0, import_classnames.default)(`${prefixCls}-treenode-motion`, motionClassName), style: motionStyle }, motionNodes.map((treeNode) => {
+        const {
+          data: { ...restProps },
+          title,
+          key,
+          isStart,
+          isEnd
+        } = treeNode;
+        delete restProps.children;
+        const treeNodeProps = (0, import_treeUtil.getTreeNodeProps)(key, treeNodeRequiredProps);
+        return /* @__PURE__ */ import_react.default.createElement(
+          import_TreeNode.default,
+          {
+            ...(0, import_omit.default)(restProps, "children"),
+            ...treeNodeProps,
+            title,
+            active,
+            data: treeNode.data,
+            key,
+            isStart,
+            isEnd
+          }
+        );
+      })));
+    }
+    return /* @__PURE__ */ import_react.default.createElement(import_TreeNode.default, { domRef: ref, className, style, ...props, active });
+  }
+);
+MotionTreeNode.displayName = "MotionTreeNode";
+var MotionTreeNode_default = MotionTreeNode;

package/dist/Tree/NodeList.d.ts

@@ -0,0 +1,43 @@
+import React, { FC } from 'react';
+import { DataEntity, FlattenNode, Key, ScrollTo } from './typings';
+export declare const MOTION_KEY: string;
+export declare const MotionEntity: DataEntity;
+export interface NodeListRef {
+    scrollTo: ScrollTo;
+    getIndentWidth: () => number;
+}
+interface NodeListProps {
+    prefixCls: string;
+    style: React.CSSProperties;
+    data: FlattenNode[];
+    motion: any;
+    focusable?: boolean;
+    activeItem: FlattenNode;
+    focused?: boolean;
+    tabIndex: number;
+    checkable?: boolean;
+    selectable?: boolean;
+    disabled?: boolean;
+    expandedKeys: Key[];
+    selectedKeys: Key[];
+    checkedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    halfCheckedKeys: Key[];
+    keyEntities: Record<Key, DataEntity<any>>;
+    dragging: boolean;
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    height: number;
+    itemHeight: number;
+    virtual?: boolean;
+    onKeyDown?: React.KeyboardEventHandler<HTMLInputElement>;
+    onFocus?: React.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+    onActiveChange: (key: Key) => void;
+    onListChangeStart: () => void;
+    onListChangeEnd: () => void;
+}
+export declare function getMinimumRangeTransitionRange(list: FlattenNode[], virtual: boolean, height: number, itemHeight: number): FlattenNode[];
+declare const NodeList: FC<NodeListProps>;
+export default NodeList;

package/dist/Tree/NodeList.js

@@ -0,0 +1,285 @@
+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/NodeList.tsx
+var NodeList_exports = {};
+__export(NodeList_exports, {
+  MOTION_KEY: () => MOTION_KEY,
+  MotionEntity: () => MotionEntity,
+  default: () => NodeList_default,
+  getMinimumRangeTransitionRange: () => getMinimumRangeTransitionRange
+});
+module.exports = __toCommonJS(NodeList_exports);
+var import_react = __toESM(require("react"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_VirtualList = require("../VirtualList");
+var import_MotionTreeNode = __toESM(require("./MotionTreeNode"));
+var import_diffUtil = require("./utils/diffUtil");
+var import_treeUtil = require("./utils/treeUtil");
+var HIDDEN_STYLE = {
+  width: 0,
+  height: 0,
+  display: "flex",
+  overflow: "hidden",
+  opacity: 0,
+  border: 0,
+  padding: 0,
+  margin: 0
+};
+var noop = () => {
+};
+var MOTION_KEY = `RC_TREE_MOTION_${Math.random()}`;
+var MotionNode = {
+  key: MOTION_KEY
+};
+var MotionEntity = {
+  key: MOTION_KEY,
+  level: 0,
+  index: 0,
+  pos: "0",
+  node: MotionNode,
+  nodes: [MotionNode]
+};
+var MotionFlattenData = {
+  parent: null,
+  children: [],
+  pos: MotionEntity.pos,
+  data: MotionNode,
+  title: null,
+  key: MOTION_KEY,
+  /** Hold empty list here since we do not use it */
+  isStart: [],
+  isEnd: []
+};
+function getMinimumRangeTransitionRange(list, virtual, height, itemHeight) {
+  if (virtual === false || !height) {
+    return list;
+  }
+  return list.slice(0, Math.ceil(height / itemHeight) + 1);
+}
+function itemKey(item) {
+  const { key, pos } = item;
+  return (0, import_treeUtil.getKey)(key, pos);
+}
+function getAccessibilityPath(item) {
+  let path = String(item.data.key);
+  let current = item;
+  while (current.parent) {
+    current = current.parent;
+    path = `${current.data.key} > ${path}`;
+  }
+  return path;
+}
+var NodeList = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    prefixCls,
+    data,
+    checkable,
+    expandedKeys,
+    selectedKeys,
+    checkedKeys,
+    loadedKeys,
+    loadingKeys,
+    halfCheckedKeys,
+    keyEntities,
+    disabled,
+    dragging,
+    dragOverNodeKey,
+    dropPosition,
+    motion,
+    height,
+    itemHeight,
+    virtual,
+    focusable,
+    activeItem,
+    focused,
+    tabIndex,
+    onKeyDown,
+    onFocus,
+    onBlur,
+    onActiveChange,
+    onListChangeStart,
+    onListChangeEnd,
+    ...domProps
+  } = props;
+  const listRef = (0, import_react.useRef)(null);
+  const indentMeasurerRef = (0, import_react.useRef)(null);
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    scrollTo: (scroll) => {
+      listRef.current.scrollTo(scroll);
+    },
+    getIndentWidth: () => indentMeasurerRef.current.offsetWidth
+  }));
+  const [prevExpandedKeys, setPrevExpandedKeys] = (0, import_react.useState)(expandedKeys);
+  const [prevData, setPrevData] = (0, import_react.useState)(data);
+  const [transitionData, setTransitionData] = (0, import_react.useState)(data);
+  const [transitionRange, setTransitionRange] = (0, import_react.useState)([]);
+  const [motionType, setMotionType] = (0, import_react.useState)(null);
+  function onMotionEnd() {
+    setPrevData(data);
+    setTransitionData(data);
+    setTransitionRange([]);
+    setMotionType(null);
+    onListChangeEnd();
+  }
+  (0, import_react.useEffect)(() => {
+    setPrevExpandedKeys(expandedKeys);
+    const diffExpanded = (0, import_diffUtil.findExpandedKeys)(prevExpandedKeys, expandedKeys);
+    if (diffExpanded.key !== null) {
+      if (diffExpanded.add) {
+        const keyIndex = prevData.findIndex(({ key }) => key === diffExpanded.key);
+        const rangeNodes = getMinimumRangeTransitionRange((0, import_diffUtil.getExpandRange)(prevData, data, diffExpanded.key), virtual, height, itemHeight);
+        const newTransitionData = prevData.slice();
+        newTransitionData.splice(keyIndex + 1, 0, MotionFlattenData);
+        setTransitionData(newTransitionData);
+        setTransitionRange(rangeNodes);
+        setMotionType("show");
+      } else {
+        const keyIndex = data.findIndex(({ key }) => key === diffExpanded.key);
+        const rangeNodes = getMinimumRangeTransitionRange((0, import_diffUtil.getExpandRange)(data, prevData, diffExpanded.key), virtual, height, itemHeight);
+        const newTransitionData = data.slice();
+        newTransitionData.splice(keyIndex + 1, 0, MotionFlattenData);
+        setTransitionData(newTransitionData);
+        setTransitionRange(rangeNodes);
+        setMotionType("hide");
+      }
+    } else if (prevData !== data) {
+      setPrevData(data);
+      setTransitionData(data);
+    }
+  }, [expandedKeys, data]);
+  (0, import_react.useEffect)(() => {
+    if (!dragging) {
+      onMotionEnd();
+    }
+  }, [dragging]);
+  const mergedData = motion ? transitionData : data;
+  const treeNodeRequiredProps = {
+    expandedKeys,
+    selectedKeys,
+    loadedKeys,
+    loadingKeys,
+    checkedKeys,
+    halfCheckedKeys,
+    dragOverNodeKey,
+    dropPosition,
+    keyEntities
+  };
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, focused && activeItem && /* @__PURE__ */ import_react.default.createElement("span", { style: HIDDEN_STYLE, "aria-live": "assertive" }, getAccessibilityPath(activeItem)), /* @__PURE__ */ import_react.default.createElement("div", null, /* @__PURE__ */ import_react.default.createElement(
+    "input",
+    {
+      style: HIDDEN_STYLE,
+      disabled: focusable === false || disabled,
+      tabIndex: focusable !== false ? tabIndex : null,
+      onKeyDown,
+      onFocus,
+      onBlur,
+      value: "",
+      onChange: noop,
+      "aria-label": "for screen reader"
+    }
+  )), /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      className: `${prefixCls}-treenode`,
+      "aria-hidden": true,
+      style: {
+        position: "absolute",
+        pointerEvents: "none",
+        visibility: "hidden",
+        height: 0,
+        overflow: "hidden"
+      }
+    },
+    /* @__PURE__ */ import_react.default.createElement("div", { className: `${prefixCls}-indent` }, /* @__PURE__ */ import_react.default.createElement("div", { ref: indentMeasurerRef, className: `${prefixCls}-indent-unit` }))
+  ), /* @__PURE__ */ import_react.default.createElement(
+    import_VirtualList.VirtualList,
+    {
+      ...domProps,
+      data: mergedData,
+      itemKey,
+      height,
+      fullHeight: false,
+      virtual,
+      itemHeight,
+      prefixCls: `${prefixCls}-list`,
+      ref: listRef,
+      onVisibleChange: (originList, fullList) => {
+        const originSet = new Set(originList);
+        const restList = fullList.filter((item) => !originSet.has(item));
+        if (restList.some((item) => itemKey(item) === MOTION_KEY)) {
+          onMotionEnd();
+        }
+      }
+    },
+    (treeNode) => {
+      const {
+        pos,
+        data: { ...restProps },
+        title,
+        key,
+        isStart,
+        isEnd
+      } = treeNode;
+      const mergedKey = (0, import_treeUtil.getKey)(key, pos);
+      delete restProps.key;
+      delete restProps.children;
+      const treeNodeProps = (0, import_treeUtil.getTreeNodeProps)(mergedKey, treeNodeRequiredProps);
+      return /* @__PURE__ */ import_react.default.createElement(
+        import_MotionTreeNode.default,
+        {
+          ...(0, import_omit.default)(restProps, "children"),
+          ...treeNodeProps,
+          title,
+          active: !!activeItem && key === activeItem.key,
+          pos,
+          data: treeNode.data,
+          isStart,
+          isEnd,
+          motion,
+          motionNodes: key === MOTION_KEY ? transitionRange : null,
+          motionType,
+          onMotionStart: onListChangeStart,
+          onMotionEnd,
+          treeNodeRequiredProps,
+          onMouseMove: () => {
+            onActiveChange(null);
+          }
+        }
+      );
+    }
+  ));
+});
+NodeList.displayName = "NodeList";
+var NodeList_default = NodeList;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MOTION_KEY,
+  MotionEntity,
+  getMinimumRangeTransitionRange
+});