@nickeylin/antd-mobile-pro 2.0.0

package/dist/es/components/tree/style/rtl.less

@@ -0,0 +1,70 @@
+@ant-prefix: suid;
+
+@tree-prefix-cls: ~'@{ant-prefix}-tree';
+@select-tree-prefix-cls: ~'@{ant-prefix}-select-tree';
+@tree-node-prefix-cls: ~'@{tree-prefix-cls}-treenode';
+
+.@{tree-prefix-cls} {
+  &-rtl {
+    direction: rtl;
+    .@{tree-prefix-cls}-node-content-wrapper[draggable='true'] {
+      .@{tree-prefix-cls}-drop-indicator {
+        &::after {
+          right: -6px;
+          left: unset;
+        }
+      }
+    }
+  }
+
+  // ===================== TreeNode =====================
+  .@{tree-node-prefix-cls} {
+    &-rtl {
+      direction: rtl;
+    }
+  }
+
+  // >>> Switcher
+  &-switcher {
+    &_close {
+      .@{tree-prefix-cls}-switcher-icon {
+        svg {
+          .@{tree-prefix-cls}-rtl & {
+            transform: rotate(90deg);
+          }
+        }
+      }
+    }
+  }
+  // ==================== Show Line =====================
+  &-show-line {
+    // ================ Indent lines ================
+    .@{tree-prefix-cls}-indent {
+      &-unit {
+        &::before {
+          .@{tree-prefix-cls}-rtl& {
+            right: auto;
+            left: calc(0px - (var(--tree-title-height) / 2) - 1px);
+            border-right: none;
+            border-left: 1px solid var(--adm-color-box);
+          }
+        }
+      }
+    }
+  }
+  // >>> Checkbox
+  &-checkbox {
+    .@{tree-prefix-cls}-rtl & {
+      margin: calc((var(--tree-title-height) - 16px) / 2) 0 0 8px;
+    }
+  }
+}
+
+.@{select-tree-prefix-cls} {
+  // >>> Checkbox
+  &-checkbox {
+    .@{tree-prefix-cls}-select-dropdown-rtl & {
+      margin: calc((var(--tree-title-height) - 16px) / 2) 0 0 8px;
+    }
+  }
+}

package/dist/es/components/tree/tree.d.ts

@@ -0,0 +1,93 @@
+import { SearchBarProps } from 'antd-mobile';
+import { NativeProps } from 'antd-mobile/es/utils/native-props';
+import type { TreeProps as RcTreeProps } from 'rc-tree';
+import RcTree from 'rc-tree';
+import type { FieldDataNode } from 'rc-tree/lib/interface';
+import { CSSProperties, RefObject } from 'react';
+import { RemoteDataProps } from '../../utils/remote-data-props';
+import { RowKey } from '../pro-list/helper';
+export type TreeDataNode<T extends object = object> = FieldDataNode<T>;
+export interface TreeProps<D extends TreeDataNode = TreeDataNode> extends Omit<RcTreeProps<D>, 'direction' | 'showLine' | 'prefixCls' | 'style' | 'treeData'>, RemoteDataProps<D[]>, NativeProps<'--title-height' | '--body-height' | '--node-padding' | '--node-hover-bg' | '--node-hightlight-color' | '--checkbox-size' | '--node-selected-bg' | '--line-color'> {
+    showLine?: boolean | {
+        showLeafIcon: boolean;
+    };
+    rowKey?: RowKey<D>;
+    treeRef?: RefObject<RcTree<D>>;
+    blockNode?: boolean;
+    prefixCls?: string;
+    /**
+     * 搜索框配置
+     */
+    search?: false | SearchBarProps;
+    bodyClassName?: string;
+    bodyStyle?: CSSProperties;
+    /** s
+     * zh-CN: 显示快速搜索
+     * en-US: Show search
+     * @deprecated use `search` instead
+     */
+    showSearch?: boolean;
+    /**
+     * zh-CN: 搜索框默认文字
+     * en-US: Placeholder of search
+     * @deprecated use `search` instead
+     */
+    searchPlaceHolder?: string;
+    /**
+     * zh-CN: 级联参数配置
+     * en-US: Cascade parameter configuration
+     */
+    cascadeParams?: object;
+}
+declare function Tree<T extends TreeDataNode = TreeDataNode>(props: TreeProps<T>): JSX.Element;
+declare namespace Tree {
+    var TreeNode: import("react").FC<import("rc-tree").TreeNodeProps<import("rc-tree/lib/interface").DataNode>>;
+    var DirectoryTree: (<T extends import("rc-tree").BasicDataNode | import("rc-tree/lib/interface").DataNode = import("rc-tree/lib/interface").DataNode>(props: import("./DirectoryTree").DirectoryTreeProps<T> & {
+        children?: import("react").ReactNode;
+    } & {
+        ref?: import("react").Ref<RcTree<import("rc-tree/lib/interface").DataNode>> | undefined;
+    }) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) & {
+        defaultProps: Partial<import("react").PropsWithChildren<import("./DirectoryTree").DirectoryTreeProps<any>>>;
+        displayName?: string | undefined;
+    };
+    var defaultProps: {
+        checkable: boolean;
+        selectable: boolean;
+        showIcon: boolean;
+        motion: {
+            motionAppear: boolean;
+            motionName?: import("rc-motion/es/CSSMotion").MotionName | undefined;
+            visible?: boolean | undefined;
+            motionEnter?: boolean | undefined;
+            motionLeave?: boolean | undefined;
+            motionLeaveImmediately?: boolean | undefined;
+            motionDeadline?: number | undefined;
+            forceRender?: boolean | undefined;
+            removeOnLeave?: boolean | undefined;
+            leavedClassName?: string | undefined;
+            eventProps?: object | undefined;
+            onAppearPrepare?: import("rc-motion/es/interface").MotionPrepareEventHandler | undefined;
+            onEnterPrepare?: import("rc-motion/es/interface").MotionPrepareEventHandler | undefined;
+            onLeavePrepare?: import("rc-motion/es/interface").MotionPrepareEventHandler | undefined;
+            onAppearStart?: import("rc-motion").MotionEventHandler | undefined;
+            onEnterStart?: import("rc-motion").MotionEventHandler | undefined;
+            onLeaveStart?: import("rc-motion").MotionEventHandler | undefined;
+            onAppearActive?: import("rc-motion").MotionEventHandler | undefined;
+            onEnterActive?: import("rc-motion").MotionEventHandler | undefined;
+            onLeaveActive?: import("rc-motion").MotionEventHandler | undefined;
+            onAppearEnd?: import("rc-motion").MotionEndEventHandler | undefined;
+            onEnterEnd?: import("rc-motion").MotionEndEventHandler | undefined;
+            onLeaveEnd?: import("rc-motion").MotionEndEventHandler | undefined;
+            onVisibleChanged?: ((visible: boolean) => void) | undefined;
+            internalRef?: import("react").Ref<any> | undefined;
+            children?: ((props: {
+                [key: string]: any;
+                visible?: boolean | undefined;
+                className?: string | undefined;
+                style?: CSSProperties | undefined;
+            }, ref: (node: any) => void) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) | undefined;
+        };
+        blockNode: boolean;
+    };
+}
+export default Tree;

package/dist/es/components/tree/tree.js

@@ -0,0 +1,197 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _excluded = ["rowKey", "titleRender", "prefixCls", "treeRef", "search", "defaultExpandAll", "className", "style", "bodyClassName", "bodyStyle", "checkable", "draggable", "showLine"];
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { MenuOutlined } from '@ant-design/icons';
+import { Empty, SearchBar, Skeleton } from 'antd-mobile';
+import classNames from 'classnames';
+import { get } from 'lodash';
+import RcTree, { TreeNode } from 'rc-tree';
+import { useMemo, useState } from 'react';
+import { cn } from "../../utils/bem";
+import { useFetchRemoteData } from "../../utils/remote-data-props";
+import { useConfig } from "../config-provider";
+import { getRowKey } from "../pro-list/helper";
+import DirectoryTree from "./DirectoryTree";
+import renderSwitcherIcon from "./utils/iconUtil";
+import collapseMotion from "./utils/motion";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var bem = cn('tree');
+
+/**
+ * 递归替换key
+ * @param treeDataArr
+ */
+function transformTreeData(treeData, rowKey, titleKey) {
+  return treeData.map(function (node, nIndex) {
+    var key = getRowKey(rowKey, node, nIndex);
+    var newObj = _objectSpread(_objectSpread({}, node), {}, {
+      key: key
+    });
+    if (newObj.children) {
+      newObj.children = transformTreeData(newObj.children, rowKey, titleKey);
+    }
+    return newObj;
+  });
+}
+function filterNodes(searchValue, treeData) {
+  var newArr = [];
+  treeData.forEach(function (treeNode) {
+    // const { children, ...treeData } = treeNode;
+    var filterName = 'name';
+    var fieldValue = get(treeNode, filterName, '') || '';
+    if (fieldValue !== '' && fieldValue !== null && fieldValue !== undefined && fieldValue.toLowerCase().indexOf(searchValue) > -1) {
+      newArr.push(treeNode);
+    } else if (treeNode.children && treeNode.children.length > 0) {
+      var ab = filterNodes(searchValue, treeNode.children);
+      var obj = _objectSpread(_objectSpread({}, treeNode), {}, {
+        children: ab
+      });
+      if (ab && ab.length > 0) {
+        newArr.push(obj);
+      }
+    }
+  });
+  return newArr;
+}
+function Tree(props) {
+  var _props$fieldNames$tit, _props$fieldNames;
+  var _props$rowKey = props.rowKey,
+    rowKey = _props$rowKey === void 0 ? 'key' : _props$rowKey,
+    titleRender = props.titleRender,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? 'suid-tree' : _props$prefixCls,
+    treeRef = props.treeRef,
+    search = props.search,
+    _props$defaultExpandA = props.defaultExpandAll,
+    defaultExpandAll = _props$defaultExpandA === void 0 ? true : _props$defaultExpandA,
+    className = props.className,
+    style = props.style,
+    bodyClassName = props.bodyClassName,
+    bodyStyle = props.bodyStyle,
+    checkable = props.checkable,
+    draggable = props.draggable,
+    showLine = props.showLine,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var _useConfig = useConfig(),
+    locale = _useConfig.locale;
+  var _useState = useState(''),
+    _useState2 = _slicedToArray(_useState, 2),
+    searchValue = _useState2[0],
+    setSearchValue = _useState2[1];
+  var titleKey = (_props$fieldNames$tit = (_props$fieldNames = props.fieldNames) === null || _props$fieldNames === void 0 ? void 0 : _props$fieldNames.title) !== null && _props$fieldNames$tit !== void 0 ? _props$fieldNames$tit : 'title';
+  var _useFetchRemoteData = useFetchRemoteData(props, {
+      componentName: 'Tree',
+      postData: function postData(d) {
+        return d ? transformTreeData(d, rowKey, titleKey) : d;
+      }
+    }),
+    data = _useFetchRemoteData.data,
+    loading = _useFetchRemoteData.loading;
+  var dataList = useMemo(function () {
+    if (!data) return [];
+    return searchValue ? filterNodes(searchValue, data) : data;
+  }, [data, searchValue]);
+  var draggableConfig = useMemo(function () {
+    if (!draggable) {
+      return false;
+    }
+    var mergedDraggable = {};
+    switch (_typeof(draggable)) {
+      case 'function':
+        mergedDraggable.nodeDraggable = draggable;
+        break;
+      case 'object':
+        mergedDraggable = _objectSpread({}, draggable);
+        break;
+      default:
+      // Do nothing
+    }
+    if (mergedDraggable.icon !== false) {
+      mergedDraggable.icon = mergedDraggable.icon || /*#__PURE__*/_jsx(MenuOutlined, {});
+    }
+    return mergedDraggable;
+  }, [draggable]);
+  return /*#__PURE__*/_jsxs("div", {
+    className: classNames(bem('wrap'), className),
+    style: style,
+    children: [search !== false && /*#__PURE__*/_jsx(SearchBar, _objectSpread({
+      className: bem('search'),
+      onSearch: function onSearch(val) {
+        setSearchValue(val);
+      },
+      onClear: /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              setSearchValue('');
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      })),
+      onCancel: /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      })),
+      placeholder: locale.ProList.keywordsPlaceholder
+    }, search)), /*#__PURE__*/_jsx("div", {
+      className: classNames(bem('body', {
+        loading: loading
+      }), bodyClassName),
+      style: bodyStyle,
+      children: loading && !data ? /*#__PURE__*/_jsx(Skeleton.Paragraph, {
+        animated: true,
+        lineCount: 10
+      }) : dataList.length == 0 ? /*#__PURE__*/_jsx(Empty, {
+        description: locale.common.noData
+      }) : /*#__PURE__*/_jsx(RcTree, _objectSpread({
+        itemHeight: 20,
+        ref: treeRef,
+        className: classNames(bem({
+          'icon-hide': !restProps.showIcon,
+          'block-node': restProps.blockNode,
+          unselectable: !restProps.selectable
+        })),
+        checkable: checkable ? /*#__PURE__*/_jsx("span", {
+          className: 'suid-tree-checkbox-inner'
+        }) : checkable,
+        switcherIcon: function switcherIcon(nodeProps) {
+          return renderSwitcherIcon(prefixCls, restProps.switcherIcon, showLine, nodeProps);
+        },
+        draggable: draggableConfig,
+        treeData: dataList,
+        defaultExpandAll: defaultExpandAll,
+        prefixCls: prefixCls,
+        showLine: typeof showLine === 'undefined' || typeof showLine === 'boolean' ? showLine : true,
+        titleRender: titleRender !== null && titleRender !== void 0 ? titleRender : function (node) {
+          return node[titleKey];
+        }
+      }, restProps))
+    })]
+  });
+}
+Tree.TreeNode = TreeNode;
+Tree.DirectoryTree = DirectoryTree;
+Tree.defaultProps = {
+  checkable: false,
+  selectable: true,
+  showIcon: false,
+  motion: _objectSpread(_objectSpread({}, collapseMotion), {}, {
+    motionAppear: false
+  }),
+  blockNode: false
+};
+export default Tree;

package/dist/es/components/tree/utils/dictUtil.d.ts

@@ -0,0 +1,9 @@
+import type { DataNode, Key } from 'rc-tree/lib/interface';
+/** 计算选中范围，只考虑expanded情况以优化性能 */
+export declare function calcRangeKeys({ treeData, expandedKeys, startKey, endKey, }: {
+    treeData: DataNode[];
+    expandedKeys: Key[];
+    startKey?: Key;
+    endKey?: Key;
+}): Key[];
+export declare function convertDirectoryKeysToNodes(treeData: DataNode[], keys: Key[]): DataNode[];

package/dist/es/components/tree/utils/dictUtil.js

@@ -0,0 +1,77 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+var Record = /*#__PURE__*/function (Record) {
+  Record[Record["None"] = 0] = "None";
+  Record[Record["Start"] = 1] = "Start";
+  Record[Record["End"] = 2] = "End";
+  return Record;
+}(Record || {});
+function traverseNodesKey(treeData, callback) {
+  function processNode(dataNode) {
+    var key = dataNode.key,
+      children = dataNode.children;
+    if (callback(key, dataNode) !== false) {
+      traverseNodesKey(children || [], callback);
+    }
+  }
+  treeData.forEach(processNode);
+}
+
+/** 计算选中范围，只考虑expanded情况以优化性能 */
+export function calcRangeKeys(_ref) {
+  var treeData = _ref.treeData,
+    expandedKeys = _ref.expandedKeys,
+    startKey = _ref.startKey,
+    endKey = _ref.endKey;
+  var keys = [];
+  var record = Record.None;
+  if (startKey && startKey === endKey) {
+    return [startKey];
+  }
+  if (!startKey || !endKey) {
+    return [];
+  }
+  function matchKey(key) {
+    return key === startKey || key === endKey;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  traverseNodesKey(treeData, function (key) {
+    if (record === Record.End) {
+      return false;
+    }
+    if (matchKey(key)) {
+      // Match test
+      keys.push(key);
+      if (record === Record.None) {
+        record = Record.Start;
+      } else if (record === Record.Start) {
+        record = Record.End;
+        return false;
+      }
+    } else if (record === Record.Start) {
+      // Append selection
+      keys.push(key);
+    }
+    if (expandedKeys.indexOf(key) === -1) {
+      return false;
+    }
+    return true;
+  });
+  return keys;
+}
+export function convertDirectoryKeysToNodes(treeData, keys) {
+  var restKeys = _toConsumableArray(keys);
+  var nodes = [];
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  traverseNodesKey(treeData, function (key, node) {
+    var index = restKeys.indexOf(key);
+    if (index !== -1) {
+      nodes.push(node);
+      restKeys.splice(index, 1);
+    }
+    return !!restKeys.length;
+  });
+  return nodes;
+}

package/dist/es/components/tree/utils/dropIndicator.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export declare const offset = 4;
+export default function dropIndicatorRender(props: {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    indent: number;
+    prefixCls: string;
+    direction: 'ltr' | 'rtl';
+}): JSX.Element;

package/dist/es/components/tree/utils/dropIndicator.js

@@ -0,0 +1,32 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var offset = 4;
+export default function dropIndicatorRender(props) {
+  var dropPosition = props.dropPosition,
+    dropLevelOffset = props.dropLevelOffset,
+    prefixCls = props.prefixCls,
+    indent = props.indent,
+    _props$direction = props.direction,
+    direction = _props$direction === void 0 ? 'ltr' : _props$direction;
+  var startPosition = direction === 'ltr' ? 'left' : 'right';
+  var endPosition = direction === 'ltr' ? 'right' : 'left';
+  var style = _defineProperty(_defineProperty({}, startPosition, -dropLevelOffset * indent + offset), endPosition, 0);
+  switch (dropPosition) {
+    case -1:
+      style.top = -3;
+      break;
+    case 1:
+      style.bottom = -3;
+      break;
+    default:
+      // dropPosition === 0
+      style.bottom = -3;
+      style[startPosition] = indent + offset;
+      break;
+  }
+  return /*#__PURE__*/_jsx("div", {
+    style: style,
+    className: "".concat(prefixCls, "-drop-indicator")
+  });
+}

package/dist/es/components/tree/utils/iconUtil.d.ts

@@ -0,0 +1,6 @@
+import { FieldDataNode, TreeNodeProps } from 'rc-tree';
+import { IconType } from 'rc-tree/lib/interface';
+import * as React from 'react';
+export default function renderSwitcherIcon<T extends FieldDataNode<object>>(prefixCls: string, switcherIcon: IconType, showLine: boolean | {
+    showLeafIcon: boolean;
+} | undefined, treeNodeProps: TreeNodeProps<T>): React.ReactNode;

package/dist/es/components/tree/utils/iconUtil.js

@@ -0,0 +1,59 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import { CaretDownFilled, FileOutlined, LoadingOutlined, MinusSquareOutlined, PlusSquareOutlined } from '@ant-design/icons';
+import classNames from 'classnames';
+import * as React from 'react';
+import { cloneElement, isValidElement } from "./reactNode";
+import { jsx as _jsx } from "react/jsx-runtime";
+export default function renderSwitcherIcon(prefixCls, switcherIcon, showLine, treeNodeProps) {
+  var isLeaf = treeNodeProps.isLeaf,
+    expanded = treeNodeProps.expanded,
+    loading = treeNodeProps.loading;
+  if (loading) {
+    return /*#__PURE__*/_jsx(LoadingOutlined, {
+      className: "".concat(prefixCls, "-switcher-loading-icon")
+    });
+  }
+  var showLeafIcon = false;
+  if (showLine && _typeof(showLine) === 'object') {
+    showLeafIcon = showLine.showLeafIcon;
+  }
+  if (isLeaf) {
+    if (showLine) {
+      if (_typeof(showLine) === 'object' && !showLeafIcon) {
+        return /*#__PURE__*/_jsx("span", {
+          className: "".concat(prefixCls, "-switcher-leaf-line")
+        });
+      }
+      return /*#__PURE__*/_jsx(FileOutlined, {
+        className: "".concat(prefixCls, "-switcher-line-icon")
+      });
+    }
+    return null;
+  }
+  var switcherCls = "".concat(prefixCls, "-switcher-icon");
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  var switcher = typeof switcherIcon === 'function' ?
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  switcherIcon(treeNodeProps) : switcherIcon;
+  if (isValidElement(switcher)) {
+    return cloneElement(switcher, {
+      className: classNames(switcher.props.className || '', switcherCls)
+    });
+  }
+  if (switcher) {
+    return switcher;
+  }
+  if (showLine) {
+    return expanded ? /*#__PURE__*/_jsx(MinusSquareOutlined, {
+      className: "".concat(prefixCls, "-switcher-line-icon")
+    }) : /*#__PURE__*/_jsx(PlusSquareOutlined, {
+      className: "".concat(prefixCls, "-switcher-line-icon")
+    });
+  }
+  return /*#__PURE__*/_jsx(CaretDownFilled, {
+    className: switcherCls
+  });
+}

package/dist/es/components/tree/utils/motion.d.ts

@@ -0,0 +1,8 @@
+import type { CSSMotionProps } from 'rc-motion';
+declare const collapseMotion: CSSMotionProps;
+declare const SelectPlacements: ["bottomLeft", "bottomRight", "topLeft", "topRight"];
+export type SelectCommonPlacement = (typeof SelectPlacements)[number];
+declare const getTransitionDirection: (placement: SelectCommonPlacement | undefined) => "slide-down" | "slide-up";
+declare const getTransitionName: (rootPrefixCls: string, motion: string, transitionName?: string) => string;
+export { getTransitionDirection, getTransitionName };
+export default collapseMotion;

package/dist/es/components/tree/utils/motion.js

@@ -0,0 +1,52 @@
+import { tuple } from "./type";
+
+// ================== Collapse Motion ==================
+var getCollapsedHeight = function getCollapsedHeight() {
+  return {
+    height: 0,
+    opacity: 0
+  };
+};
+var getRealHeight = function getRealHeight(node) {
+  var scrollHeight = node.scrollHeight;
+  return {
+    height: scrollHeight,
+    opacity: 1
+  };
+};
+var getCurrentHeight = function getCurrentHeight(node) {
+  return {
+    height: node ? node.offsetHeight : 0
+  };
+};
+var skipOpacityTransition = function skipOpacityTransition(_, event) {
+  return (event === null || event === void 0 ? void 0 : event.deadline) === true || event.propertyName === 'height';
+};
+var collapseMotion = {
+  motionName: 'ant-motion-collapse',
+  onAppearStart: getCollapsedHeight,
+  onEnterStart: getCollapsedHeight,
+  onAppearActive: getRealHeight,
+  onEnterActive: getRealHeight,
+  onLeaveStart: getCurrentHeight,
+  onLeaveActive: getCollapsedHeight,
+  onAppearEnd: skipOpacityTransition,
+  onEnterEnd: skipOpacityTransition,
+  onLeaveEnd: skipOpacityTransition,
+  motionDeadline: 500
+};
+var SelectPlacements = tuple('bottomLeft', 'bottomRight', 'topLeft', 'topRight');
+var getTransitionDirection = function getTransitionDirection(placement) {
+  if (placement !== undefined && (placement === 'topLeft' || placement === 'topRight')) {
+    return "slide-down";
+  }
+  return "slide-up";
+};
+var getTransitionName = function getTransitionName(rootPrefixCls, motion, transitionName) {
+  if (transitionName !== undefined) {
+    return transitionName;
+  }
+  return "".concat(rootPrefixCls, "-").concat(motion);
+};
+export { getTransitionDirection, getTransitionName };
+export default collapseMotion;

package/dist/es/components/tree/utils/reactNode.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export declare const isValidElement: typeof React.isValidElement;
+export declare function isFragment(child: React.ReactElement): boolean;
+type AnyObject = Record<PropertyKey, any>;
+type RenderProps = AnyObject | ((originProps: AnyObject) => AnyObject | void);
+export declare function replaceElement(element: React.ReactNode, replacement: React.ReactNode, props?: RenderProps): React.ReactNode;
+export declare function cloneElement(element: React.ReactNode, props?: RenderProps): React.ReactElement;
+export {};

package/dist/es/components/tree/utils/reactNode.js

@@ -0,0 +1,15 @@
+import * as React from 'react';
+var isValidElement = React.isValidElement;
+export { isValidElement };
+export function isFragment(child) {
+  return child && child.type === React.Fragment;
+}
+export function replaceElement(element, replacement, props) {
+  if (!isValidElement(element)) {
+    return replacement;
+  }
+  return /*#__PURE__*/React.cloneElement(element, typeof props === 'function' ? props(element.props || {}) : props);
+}
+export function cloneElement(element, props) {
+  return replaceElement(element, element, props);
+}

package/dist/es/components/tree/utils/type.d.ts

@@ -0,0 +1,9 @@
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare const tupleNum: <T extends number[]>(...args: T) => T;
+/**
+ * https://stackoverflow.com/a/59187769 Extract the type of an element of an array/tuple without
+ * performing indexing
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer F)[] ? F : never;
+/** https://github.com/Microsoft/TypeScript/issues/29729 */
+export type LiteralUnion<T extends U, U> = T | (U & object);