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

package/dist/Cascader/Utils.js

@@ -1,8 +1,6 @@
-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)
@@ -16,25 +14,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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/Cascader/Utils.ts
 var Utils_exports = {};
 __export(Utils_exports, {
-  reOrgTree: () => reOrgTree,
   toArray: () => toArray
 });
 module.exports = __toCommonJS(Utils_exports);
-var import_cloneDeep = __toESM(require("lodash/cloneDeep"));
-var import_omit = __toESM(require("lodash/omit"));
 var import_Util = require("../Util");
 var toArray = (val, separator = "/") => {
   if ((0, import_Util.isNotEmpty)(val)) {
@@ -46,38 +33,7 @@ var toArray = (val, separator = "/") => {
   }
   return [];
 };
-var reOrgTree = (treeData, level, { valueKey = "value", labelKey = "label", leafKey = "leaf", childrenKey = "children" }, { valueKey: treeValueKey = "key", labelKey: treeLabelKey = "title", childrenKey: treeChildrenKey = "children" }, plainData = [], parent = null) => {
-  return treeData.map((node) => {
-    if (node[childrenKey]) {
-      node[childrenKey] = reOrgTree(
-        node[childrenKey],
-        level,
-        { valueKey, labelKey, leafKey, childrenKey },
-        { valueKey: treeValueKey, labelKey: treeLabelKey, childrenKey: treeChildrenKey },
-        plainData,
-        (0, import_omit.default)((0, import_cloneDeep.default)(node), childrenKey)
-      );
-    }
-    const id = (0, import_Util.randomCode)(11);
-    plainData.push({
-      __id: id,
-      __level: level,
-      __pId: (parent == null ? void 0 : parent.__id) ?? "0",
-      [valueKey]: node[treeValueKey],
-      [labelKey]: node[treeLabelKey],
-      [leafKey]: false,
-      treeChildren: Object.prototype.hasOwnProperty.call(node, treeChildrenKey),
-      ...parent != null ? { parent } : {}
-    });
-    return {
-      ...node,
-      __id: id,
-      __pId: (parent == null ? void 0 : parent.__id) ?? "0"
-    };
-  });
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  reOrgTree,
   toArray
 });

package/dist/Cascader/index.d.ts

@@ -1,2 +1,2 @@
 export { default as Cascader } from './Cascader';
-export type { CascaderMenuProps, CascaderProps, TreeMenuProps } from './typings';
+export type { CascaderMenuProps, CascaderProps } from './typings';

package/dist/Cascader/typings.d.ts

@@ -1,79 +1,143 @@
 import React from 'react';
 import { InputRef } from '../Input';
 import { PopperOptions } from '../Popper';
-import { DataNode, DirectoryTreeProps, Key } from '../Tree';
 import { AnimationEventProps, BaseProps, FormControlBaseProps, NativeProps } from '../types/common';
 export type ValueType = string[] | string[][];
-export interface CascaderProps<V = ValueType, S = DataNode> extends Omit<FormControlBaseProps<V>, 'onChange' | 'value' | 'defaultValue'>, BaseProps, NativeProps, AnimationEventProps, PopperOptions, Omit<DirectoryTreeProps<S>, 'children' | 'style' | 'expandedKeys' | 'className' | 'readOnly' | 'disabled'> {
+export interface CascaderProps<V = ValueType, S = any> extends Omit<FormControlBaseProps<V>, 'onChange' | 'value' | 'defaultValue'>, BaseProps, NativeProps, AnimationEventProps, PopperOptions {
+    /** 初始值 */
     defaultValue?: ValueType;
+    /** 值（可控） */
     value?: ValueType;
+    /** 可选项数据源，键名可通过 Props 属性配置 */
     options?: any[];
+    /** 配置选项 */
     props?: CascaderMenuProps;
-    treeMenuProps?: TreeMenuProps;
+    /** 是否禁用 */
     disabled?: boolean;
+    /** 是否可以清空选项 */
     clearable?: boolean;
+    /** 输入框中是否显示选中值的完整路径 */
     showAllLevels?: boolean;
+    /** 用于分隔选项的字符 */
     separator?: string;
+    /** 是否可搜索 */
     filterable?: boolean;
+    /** 自定义搜索方法 */
     filterMethod?: (val: ValueType, searchText: string) => boolean;
+    /** 占位符 */
     placeholder?: string;
+    /** 选项为空时显示的文字 */
     noDataText?: string;
+    /** 搜索条件无匹配时显示的文字 */
     noMatchText?: string;
+    /** 是否正在从远程获取数据 */
     loading?: boolean;
+    /** 远程加载时显示的文字 */
     loadingText?: string;
+    /**  */
     required?: boolean;
+    /** 表单校验错误提示 */
     error?: boolean;
+    /** 表单校验警告提示 */
     warning?: boolean;
+    /** 多选时是否将选中值按文字的形式展示 */
     collapseTags?: boolean;
+    /** 需要显示的 Tag 的最大数量 只有当 collapseTags 设置为 true 时才会生效。 */
     maxCollapseTags?: number;
+    /** 当鼠标悬停于折叠标签的文本时，是否显示所有选中的标签。 要使用此属性，collapseTags属性必须设定为 true */
     collapseTagsTooltip?: boolean;
+    /** 鼠标悬停于折叠标签的文本格式化函数， 要使用此属性，collapseTags属性必须设定为 true */
     collapseTips?: (collapseNum: number, total: number) => string;
+    /** 是否纯文本模式，即无边框 */
     plain?: boolean;
+    /** 输入框头部内容，只对 type="text" 有效 */
     prefix?: React.ReactElement<any> | string | number;
+    /** 输入框尾部内容，只对 type="text" 有效 */
     suffix?: React.ReactElement<any> | string | number;
+    /** 输入框前置内容，只对 type="text" 有效 */
     prepend?: React.ReactElement<any> | string | number;
+    /** 输入框后置内容，只对 type="text" 有效 */
     append?: React.ReactElement | string | number;
-    expandedKeys?: Key[][];
     lable?: string;
+    /** 是否追加到body下 */
     appendToBody?: boolean;
+    /** 选中值发生变化时触发 */
     onChange?: (value: ValueType, level?: number, label?: string | string[], node?: S[] | S[][]) => void;
+    /** 是否可以选择 */
     shouldSelect?: (node?: object, level?: number) => boolean;
     labelFormatter?: (level?: number, node?: object[]) => string;
 }
 export interface CascaderMenuProps {
+    /** 次级菜单的展开方式 */
     expandTrigger?: 'click' | 'hover';
+    /** 是否多选 */
     multiple?: boolean;
+    /** 是否严格的遵守父子节点不互相关联 */
     checkStrictly?: boolean;
+    /** 在选中节点改变时，是否返回由该节点所在的各级菜单的值所组成的数组，若设置 false，则只返回该节点的值 */
     emitPath?: boolean;
+    /** 是否动态加载子节点，需与 lazyLoad 方法结合使用 */
     lazy?: boolean;
-    lazyLoad?: (node: object, resolve?: (value: object[], isTree?: boolean) => void, reject?: () => void) => void;
-    valueKey?: string;
-    labelKey?: string;
-    childrenKey?: string;
-    disabledKey?: string;
-    leafKey?: string;
-}
-export interface TreeMenuProps {
+    /** 加载动态数据的方法，仅在 lazy 为 true 时有效 */
+    lazyLoad?: (node: object, resolve?: (value: object[]) => void, reject?: () => void) => void;
+    /** 指定选项的值为选项对象的某个属性值 */
     valueKey?: string;
+    /** 指定选项标签为选项对象的某个属性值 */
     labelKey?: string;
+    /** 指定选项的子选项为选项对象的某个属性值 */
     childrenKey?: string;
+    /** 指定选项的禁用为选项对象的某个属性值 */
     disabledKey?: string;
+    /** 指定选项的叶子节点的标志位为选项对象的某个属性值 */
     leafKey?: string;
 }
 export interface CascaderRef {
     inputInstance?: InputRef;
     setLabel: (label: string) => void;
     onClear: () => void;
+    /** 重置懒加载的节点，适用于动态懒加载配置 */
     resetNodes: () => void;
     setVisible: (visible: boolean) => void;
 }
 export interface OptionNode extends Object {
+    /**
+     * 主键
+     * @private
+     */
     __id: string;
+    /**
+     * 父级节点ID
+     * @private
+     */
     __pId: string;
+    /**
+     * 层级
+     * @private
+     */
     __level?: number;
+    /**
+     * 是否叶子节点
+     * @private
+     */
     __leaf?: boolean;
+    /**
+     * 是否已勾选
+     * @private
+     */
     __checked?: boolean;
+    /**
+     * 是否半选
+     * @private
+     */
     __indeterminate?: boolean;
+    /**
+     * 时子节点集合
+     * @private
+     */
     children?: OptionNode[];
+    /**
+     * 树形组件时子节点集合
+     * @private
+     */
     treeChildren?: boolean;
 }

package/dist/Cascader/useCascader.d.ts

@@ -1,29 +1,87 @@
 import { Key } from '../Tree';
 import { CascaderProps, OptionNode } from './typings';
 export declare const useCascader: (initialData: object[], props: CascaderProps, value: string[] | string[][]) => {
+    /** 最高层级 */
     allLevel: number;
+    /** 选项数据 */
     optionData: Record<string, OptionNode[]>;
-    storeOptionData: (nodes: object[], level: number, parent: OptionNode, { isTree, isCover }: {
-        isTree?: boolean;
+    /**
+     * 懒加载时存储option
+     * @param nodes
+     * @param level 层级
+     */
+    storeOptionData: (nodes: object[], level: number, parent: OptionNode, { isCover }: {
         isCover?: boolean;
     }) => OptionNode[];
+    /**
+     * 获取选中的值
+     * @param level 层级
+     * @returns
+     */
     getSelectedValue: () => string[];
+    /**
+     * 获取任意层级选中的值
+     * @param level 层级
+     * @returns
+     */
     getValueOfLevel: (level?: number) => string;
+    /**
+     * 获取选中的文本
+     * @param level 层级
+     * @returns
+     */
     getSelectedLabel: (labelFormatter?: (node?: OptionNode[]) => string) => string;
+    /**
+     * 设置任意层级节点的标签
+     * @param level 层级
+     * @param value
+     */
     setSelectedNode: (level: number, node: OptionNode) => void;
     setSelectedValue: (level: number, val: string) => void;
     getSelectedNode: () => OptionNode[];
+    /**
+     * 设置选中节点
+     * @param level 层级
+     * @param node 当前节点
+     * @param checked 是否选中
+     */
     setCheckedNode: (level: number, node: OptionNode, checked: boolean) => void;
     getCheckedNodes: () => OptionNode[][];
     getCheckedValue: () => string[][];
     getCheckedLabel: () => any[][];
     loopGetParent: (level: number, node: OptionNode, result?: OptionNode[]) => OptionNode[];
+    /**
+     * 获取任意节点的option数据
+     * @param level 层级
+     * @returns
+     */
     getOptions: (level: number) => OptionNode[];
+    /** 清空值 */
     clearSelected: () => void;
+    /**
+     * 设置节点是否为叶子节点
+     * @param node
+     * @param isLeaf
+     */
     setNodeLeaf: (node: OptionNode, isLeaf: boolean) => void;
+    /**
+     * 获取数据类型
+     * @param level 层级
+     * @returns
+     */
     getDataType: (level: number) => any;
-    getTreeData: (level: number) => any[];
+    /**
+     * 获取扩展key
+     * @param level 层级
+     * @returns
+     */
     getExpandedKeys: (level: number) => Key[];
+    /**
+     * 设置扩展key
+     * @param level 层级
+     * @param keys
+     * @returns
+     */
     setExpandedKeys: (level: number, keys: Key[]) => void;
     handleSearch: (searchText: string) => OptionNode[][];
     resetNodes: () => void;

package/dist/Cascader/useCascader.js

@@ -38,12 +38,10 @@ var import_isEqual = __toESM(require("lodash/isEqual"));
 var import_last = __toESM(require("lodash/last"));
 var import_react = require("react");
 var import_Util = require("../Util");
-var import_Utils = require("./Utils");
 var useCascader = (initialData, props, value) => {
-  const { props: menuProps, treeMenuProps, showAllLevels, separator, expandedKeys = [] } = props;
+  const { props: menuProps, showAllLevels, separator } = props;
   const { childrenKey = "children", valueKey = "value", labelKey = "label", leafKey = "leaf", lazy } = menuProps;
   const [allLevel, setAllLevel] = (0, import_react.useState)(0);
-  const [treeData, setTreeData] = (0, import_react.useState)({});
   const [dataTypes, setDataTypes] = (0, import_react.useState)([]);
   const _dataTypes = (0, import_react.useRef)([]);
   const [optionData, setOptionData] = (0, import_react.useState)({});
@@ -301,26 +299,18 @@ var useCascader = (initialData, props, value) => {
     }
   }, []);
   const storeOptionData = (0, import_react.useCallback)(
-    (nodes, level, parent, { isTree, isCover }) => {
+    (nodes, level, parent, { isCover }) => {
       let data = (0, import_cloneDeep.default)(_optionData.current);
       let newNodes = [];
-      if (isTree) {
-        const treeNodes = (0, import_Utils.reOrgTree)(nodes, level, menuProps, treeMenuProps, newNodes);
-        setTreeData({
-          ...treeData,
-          [`level${level}`]: treeNodes
-        });
-      } else {
-        newNodes = nodes.map((node) => ({
-          ...node,
-          __level: level,
-          __id: (0, import_Util.randomCode)(11),
-          __pId: (parent == null ? void 0 : parent.__id) ?? "0",
-          __leaf: node[leafKey] ?? false,
-          __checked: false,
-          __indeterminate: false
-        }));
-      }
+      newNodes = nodes.map((node) => ({
+        ...node,
+        __level: level,
+        __id: (0, import_Util.randomCode)(11),
+        __pId: (parent == null ? void 0 : parent.__id) ?? "0",
+        __leaf: node[leafKey] ?? false,
+        __checked: false,
+        __indeterminate: false
+      }));
       if ((0, import_Util.isEmpty)(data[`level${level}`])) {
         data = {
           ...data,
@@ -350,19 +340,19 @@ var useCascader = (initialData, props, value) => {
           selectedValue.current.push(null);
           selectedLabel.current.push(null);
           selectedNode.current.push(null);
-          setDataTypes(_dataTypes.current = [..._dataTypes.current, isTree ? true : false]);
+          setDataTypes(_dataTypes.current);
         }
       } else {
         selectedValue.current[level] = null;
         selectedLabel.current[level] = null;
         selectedNode.current[level] = null;
         const _types = (0, import_cloneDeep.default)(_dataTypes.current);
-        _types[level] = isTree ? true : false;
+        _types[level] = false;
         setDataTypes(_dataTypes.current = _types);
       }
       return data[`level${level}`];
     },
-    [allLevel, childrenKey, leafKey, menuProps, treeData, treeMenuProps]
+    [allLevel, childrenKey, leafKey]
   );
   const setNodeLeaf = (0, import_react.useCallback)(
     (node, isLeaf) => {
@@ -380,12 +370,6 @@ var useCascader = (initialData, props, value) => {
     },
     [dataTypes, lazy]
   );
-  const getTreeData = (0, import_react.useCallback)(
-    (level) => {
-      return lazy && treeData[`level${level}`];
-    },
-    [lazy, treeData]
-  );
   const getExpandedKeys = (0, import_react.useCallback)((level) => {
     return expandKeys.current[`level${level}`] ?? [];
   }, []);
@@ -511,11 +495,6 @@ var useCascader = (initialData, props, value) => {
       }
     }
   }, [value, allLevel, props.options]);
-  (0, import_react.useEffect)(() => {
-    expandedKeys.forEach((keys, level) => {
-      setExpandedKeys(level, keys);
-    });
-  }, [expandedKeys, setExpandedKeys]);
   return {
     // eslint-disable-next-line lines-around-comment
     /** 最高层级 */
@@ -585,12 +564,6 @@ var useCascader = (initialData, props, value) => {
      * @returns
      */
     getDataType,
-    /**
-     * 获取树数据
-     * @param level 层级
-     * @returns
-     */
-    getTreeData,
     /**
      * 获取扩展key
      * @param level 层级

package/dist/Checkbox/Checkbox.js

@@ -51,7 +51,7 @@ var Checkbox = (0, import_react.memo)(
       checked: controlledChecked,
       className,
       children,
-      defaultChecked,
+      defaultChecked = false,
       title,
       indeterminate,
       readOnly = readOnlyContext,
@@ -60,7 +60,7 @@ var Checkbox = (0, import_react.memo)(
       onClick,
       onCheckboxClick,
       onChange,
-      prevent,
+      prevent = false,
       onMouseEnter,
       onMouseLeave,
       ...rest
@@ -160,9 +160,5 @@ var Checkbox = (0, import_react.memo)(
     return title ? /* @__PURE__ */ import_react.default.createElement(import_Tooltip.default, { content: title }, main) : main;
   })
 );
-Checkbox.defaultProps = {
-  prevent: false,
-  defaultChecked: false
-};
 Checkbox.displayName = "ElCheckbox";
 var Checkbox_default = Checkbox;

package/dist/Checkbox/CheckboxButton.js

@@ -50,7 +50,7 @@ var CheckboxButton = (0, import_react.forwardRef)((props, ref) => {
     checked: controlledChecked,
     className,
     children,
-    defaultChecked,
+    defaultChecked = false,
     title,
     indeterminate,
     readOnly = readOnlyContext,
@@ -59,7 +59,7 @@ var CheckboxButton = (0, import_react.forwardRef)((props, ref) => {
     onClick,
     onCheckboxClick,
     onChange,
-    prevent,
+    prevent = false,
     onMouseEnter,
     onMouseLeave,
     ...rest
@@ -158,9 +158,5 @@ var CheckboxButton = (0, import_react.forwardRef)((props, ref) => {
   return title ? /* @__PURE__ */ import_react.default.createElement(import_Tooltip.default, { content: title }, main) : main;
 });
 var Comp = (0, import_react.memo)(CheckboxButton);
-Comp.defaultProps = {
-  prevent: false,
-  defaultChecked: false
-};
 Comp.displayName = "ElCheckboxButton";
 var CheckboxButton_default = Comp;

package/dist/Checkbox/typings.d.ts

@@ -7,15 +7,26 @@ export type CheckboxRef = {
     setChecked: (value: boolean) => void;
 };
 export interface CheckboxProps<V = ValueType> extends Omit<React.AllHTMLAttributes<HTMLElement>, 'value' | 'defaultValue' | 'loading' | 'size' | 'icon' | 'style' | 'onChange' | 'children'>, Omit<FormControlBaseProps<V>, 'onChange'>, BaseProps, NativeProps {
+    /** tooltip 提示*/
     title?: string;
+    /** Inline layout */
     inline?: boolean;
+    /** 是否只读 */
     readOnly?: boolean;
+    /** 是否选中 */
     checked?: boolean;
+    /** 默认是否选中 */
     defaultChecked?: boolean;
+    /** 是否中间状态 */
     indeterminate?: boolean;
+    /** 原生 name 属性 */
     name?: string;
+    /** 点击checkbox时是否阻止默认事件 */
     prevent?: boolean;
+    /** 当绑定值变化时触发的事件 */
     onChange?: (checked: boolean, value: ValueType, event: React.ChangeEvent<HTMLInputElement>) => void;
+    /** 点击checkbox顶级div事件 */
     onClick?: (event: React.MouseEvent<HTMLLabelElement, MouseEvent>) => void;
+    /** 点击checkbox事件 */
     onCheckboxClick?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
 }

package/dist/CheckboxGroup/CheckboxGroup.d.ts

@@ -3,9 +3,13 @@ import type { ValueType } from '../Checkbox/index';
 import { BaseProps, FormControlBaseProps, NativeProps, TypeAttributes } from '../types/common';
 export interface CheckboxGroupProps<V = ValueType[] | boolean> extends FormControlBaseProps<V>, BaseProps, NativeProps {
     name?: string;
+    /** 尺寸 */
     size?: TypeAttributes.Size;
+    /** 单个CheckBox时获取Boolean类型的值 */
     getBooleanOnSingle?: boolean;
+    /** 可被勾选的 checkbox 的最小数量 */
     min?: number;
+    /** 可被勾选的 checkbox 的最大数量 */
     max?: number;
 }
 declare const CheckboxGroup: FC<CheckboxGroupProps>;

package/dist/CheckboxGroup/CheckboxGroupContext.d.ts

@@ -9,6 +9,7 @@ export interface CheckboxGroupContextValue {
     disabled?: boolean;
     readOnly?: boolean;
     plaintext?: boolean;
+    /** 尺寸 */
     size?: TypeAttributes.Size;
     onChange?: (value: any, checked: boolean, event: any) => void;
 }

package/dist/Col/Col.js

@@ -39,7 +39,7 @@ var import_Row = require("../Row");
 var import_Util = require("../Util");
 var import_hooks = require("../hooks");
 var Col = (0, import_react.memo)((props) => {
-  const { tag = "div", span, offset, push, pull, classPrefix = "col" } = props;
+  const { tag = "div", span = 24, offset = 0, push = 0, pull = 0, classPrefix = "col" } = props;
   const { wb, b, is } = (0, import_hooks.useClassNames)(classPrefix);
   const { gutter = 0 } = (0, import_react.useContext)(import_Row.RowContext);
   const mediaClassName = (0, import_react.useMemo)(() => {
@@ -79,11 +79,4 @@ var Col = (0, import_react.memo)((props) => {
     props.children
   );
 });
-Col.defaultProps = {
-  span: 24,
-  offset: 0,
-  push: 0,
-  pull: 0,
-  tag: "div"
-};
 var Col_default = Col;

package/dist/Col/typings.d.ts

@@ -3,14 +3,24 @@ export type MediaType = keyof Pick<ColProps, 'span' | 'offset' | 'push' | 'pull'
 export type MediaLayout = Partial<Record<MediaType, number>>;
 export type MediaSize = Pick<ColProps, 'xs' | 'sm' | 'md' | 'lg' | 'xl'>;
 export interface ColProps extends BaseProps, NativeProps {
+    /** 栅格占据的列数 */
     span?: number;
+    /** 栅格左侧的间隔格数 */
     offset?: number;
+    /** 栅格向右移动格数 */
     push?: number;
+    /** 栅格向左移动格数 */
     pull?: number;
+    /** <768px 响应式栅格数或者栅格属性对象 */
     xs?: number | MediaLayout;
+    /** ≥768px 响应式栅格数或者栅格属性对象 */
     sm?: number | MediaLayout;
+    /** ≥992px 响应式栅格数或者栅格属性对象 */
     md?: number | MediaLayout;
+    /** ≥1200px 响应式栅格数或者栅格属性对象 */
     lg?: number | MediaLayout;
+    /** ≥1920px 响应式栅格数或者栅格属性对象 */
     xl?: number | MediaLayout;
+    /** 自定义元素标签 */
     tag?: string;
 }

package/dist/Collapse/CollapseContext.d.ts

@@ -1,9 +1,12 @@
 /// <reference types="react" />
 import { CollapseProps } from './typings';
 interface CollapseContextProps {
+    /** 当前激活的面板(可控模式：如果是手风琴模式，绑定值类型需要为string，否则为array) */
     value: CollapseProps['activeName'];
     setValue: (value: CollapseProps['activeName']) => void;
+    /** 是否手风琴模式 */
     accordion: boolean;
+    /** 当前激活面板改变时触发(如果是手风琴模式，参数 activeNames 类型为string，否则为array) */
     onChange: (activeNames: string | string[]) => void;
 }
 export declare const CollapseContext: import("react").Context<CollapseContextProps>;

package/dist/Collapse/CollapseItem.js

@@ -43,6 +43,7 @@ var CollapseItem = (0, import_react.memo)((props) => {
   const { name, title, disabled, classPrefix = "collapse-item" } = props;
   const { b, e, is } = (0, import_hooks.useClassNames)(classPrefix);
   const { value, setValue, accordion, onChange } = (0, import_react.useContext)(import_CollapseContext.CollapseContext);
+  const containerRef = (0, import_react.useRef)(null);
   const active = (0, import_react.useMemo)(() => {
     if (accordion && typeof value === "string") {
       return name === value;
@@ -77,17 +78,18 @@ var CollapseItem = (0, import_react.memo)((props) => {
   return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b(), is({ active, disabled }), props.className), style: props.style }, /* @__PURE__ */ import_react.default.createElement("div", null, /* @__PURE__ */ import_react.default.createElement("div", { className: e`header`, onClick: handleClick }, title, /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "angle-right", className: (0, import_classnames.default)(e`arrow`, is({ active })) }))), /* @__PURE__ */ import_react.default.createElement(
     import_Transition.Transition,
     {
-      name: "r-menu-collapse",
+      nodeRef: containerRef,
+      name: b("menu-collapse", false),
       duration: 300,
       visible: active,
-      beforeEnter: import_CollapseTransition.beforeEnter,
-      onEnter: import_CollapseTransition.onEnter,
-      afterEnter: import_CollapseTransition.afterEnter,
-      beforeLeave: import_CollapseTransition.beforeLeave,
-      onLeave: import_CollapseTransition.onLeave,
-      afterLeave: import_CollapseTransition.afterLeave
+      beforeEnter: () => (0, import_CollapseTransition.beforeEnter)(containerRef),
+      onEnter: () => (0, import_CollapseTransition.onEnter)(containerRef),
+      afterEnter: () => (0, import_CollapseTransition.afterEnter)(containerRef),
+      beforeLeave: () => (0, import_CollapseTransition.beforeLeave)(containerRef),
+      onLeave: () => (0, import_CollapseTransition.onLeave)(containerRef),
+      afterLeave: () => (0, import_CollapseTransition.afterLeave)(containerRef)
     },
-    /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(e`wrap`), style: { display: "none" } }, /* @__PURE__ */ import_react.default.createElement("div", { className: e`content` }, props.children))
+    /* @__PURE__ */ import_react.default.createElement("div", { ref: containerRef, className: (0, import_classnames.default)(e`wrap`), style: { display: "none" } }, /* @__PURE__ */ import_react.default.createElement("div", { className: e`content` }, props.children))
   ));
 });
 CollapseItem.displayName = "CollapseItem";

package/dist/Collapse/CollapseTransition.d.ts

@@ -1,6 +1,7 @@
-export declare const beforeEnter: (el: any) => void;
-export declare const onEnter: (el: HTMLElement) => void;
-export declare const afterEnter: (el: HTMLElement) => void;
-export declare const beforeLeave: (el: any) => void;
-export declare const onLeave: (el: any) => void;
-export declare const afterLeave: (el: any) => void;
+import { RefObject } from 'react';
+export declare const beforeEnter: (node: RefObject<HTMLElement>) => void;
+export declare const onEnter: (node: RefObject<HTMLElement>) => void;
+export declare const afterEnter: (node: RefObject<HTMLElement>) => void;
+export declare const beforeLeave: (node: RefObject<any>) => void;
+export declare const onLeave: (node: RefObject<any>) => void;
+export declare const afterLeave: (node: RefObject<HTMLElement>) => void;