@qsxy/element-plus-react 1.0.0-next.2 → 1.0.0-next.3

package/dist/TimeLine/typings.d.ts

@@ -3,13 +3,22 @@ import { IconName } from '../Icon';
 import { BaseProps, NativeProps } from '../types/common';
 export type TimeLineProps = BaseProps & NativeProps<'--el-timeline-node-size-normal' | '--el-timeline-node-size-large' | '--el-timeline-timestamp-color' | '--el-timeline-content-color' | '--el-timeline-content-font-size-small' | '--el-timeline-content-font-size-large' | '--el-timeline-node-color'>;
 export type TimeLineItemProps = BaseProps & NativeProps & {
+    /** 时间戳 */
     timestamp?: string;
+    /** 是否隐藏时间戳 */
     hideTimestamp?: boolean;
+    /** 是否垂直居中 */
     center?: boolean;
+    /** 时间戳位置 */
     placement?: 'top' | 'bottom';
+    /** 节点类型 */
     type?: 'primary' | 'success' | 'warning' | 'error' | 'info';
+    /** 节点颜色 */
     color?: string;
+    /** 节点尺寸 */
     size?: 'normal' | 'large';
+    /** 自定义图标 */
     icon?: IconName | React.ReactElement<any>;
+    /** 是否空心点 */
     hollow?: boolean;
 };

package/dist/TimePicker/typings.d.ts

@@ -36,8 +36,11 @@ export type TimePickerProps = Omit<DatePickerProps, 'type' | 'instance'> & {
     disabledHours?: DisabledHours;
     disabledMinutes?: DisabledMinutes;
     disabledSeconds?: DisabledSeconds;
+    /** 等价于原生 name 属性 */
     name?: string;
+    /** 选中项绑定值 */
     value?: string;
+    /** 默认值 */
     defaultValue?: string;
 };
 export type TimePickerRangeProps = Omit<DatePickerRangeProps, 'type' | 'instance'> & {
@@ -47,26 +50,36 @@ export type TimePickerRangeProps = Omit<DatePickerRangeProps, 'type' | 'instance
     instance?: RefObject<TimePickerRangeRef>;
 };
 export interface TimeSpinnerProps extends BaseProps, NativeProps, AnimationEventProps {
+    /** 值 */
     value: Dayjs;
     disabledHours?: DisabledHours;
     disabledMinutes?: DisabledMinutes;
     disabledSeconds?: DisabledSeconds;
     showSeconds?: boolean;
     role?: RoleType;
+    /** 单选框提交数据方法 */
     onChange: (value: Dayjs, params?: ChangeParams) => void;
     setSelectionRange?: (start: number, end: number, pos?: 'min' | 'max') => void;
 }
 export interface TimePanelProps extends BaseProps, NativeProps, AnimationEventProps, TimeSpinnerProps {
+    /** 是否显示 */
     visible?: boolean;
+    /**  */
     referenceElement: RefObject<HTMLElement> | (() => RefObject<HTMLElement>);
+    /** 关闭时回调函数 */
     onDestroy: () => void;
+    /** 单选框提交数据方法 */
     onOk: () => void;
 }
 export interface TimeRangePanelProps extends BaseProps, NativeProps, AnimationEventProps, Omit<TimeSpinnerProps, 'value' | 'onChange'>, Omit<TimePickerRangeProps, 'instance' | 'value' | 'onChange'> {
     value: ValueRagne;
     onChange: (value: ValueRagne, params?: ChangeParams) => void;
+    /** 是否显示 */
     visible: boolean;
+    /**  */
+    /** 关闭时回调函数 */
     onDestroy?: () => void;
+    /** 单选框提交数据方法 */
     onOk: () => void;
 }
 export interface TimePanelRef {

package/dist/TimePicker/useTimePicker.d.ts

@@ -1,3 +1,10 @@
+/**
+ * @author	Element Plus
+ * @CreateTime	2022/4/1 09:09:12
+ * @LastEditor	Parker
+ * @ModifyTime	2022/4/6 14:44:01
+ * @Description	Element Plus 时间选择面板工具类，见https://github.com/element-plus/element-plus
+ */
 import { Compare, DisabledHours, DisabledMinutes, DisabledSeconds, RoleType } from './typings';
 export declare const getTimeLists: (disabledHours: DisabledHours, disabledMinutes: DisabledMinutes, disabledSeconds: DisabledSeconds) => {
     getHoursList: (role: RoleType, compare?: Compare) => boolean[];

package/dist/Tooltip/Tooltip.js

@@ -38,29 +38,17 @@ var import_react = __toESM(require("react"));
 var ReactIs = __toESM(require("react-is"));
 var import_hooks = require("../hooks");
 var import_Popper = require("../Popper");
-var import_Util = require("../Util");
 var import_TooltipContext = require("./TooltipContext");
 var Tooltip = (0, import_react.forwardRef)((props, ref) => {
-  props = (0, import_Util.mergeDefaultProps)(
-    {
-      effect: "dark",
-      showArrow: true,
-      showAfter: 0,
-      hideAfter: 200,
-      trigger: "hover",
-      unmountOnExit: true
-    },
-    props
-  );
   const {
     classPrefix = "tooltip",
-    effect: theme,
-    trigger,
+    effect = "dark",
+    trigger = "hover",
     content,
     disabled,
-    enterable,
-    showAfter,
-    hideAfter,
+    enterable = true,
+    showAfter = 0,
+    hideAfter = 200,
     onMouseEnter,
     onMouseLeave,
     onEnter,
@@ -68,6 +56,7 @@ var Tooltip = (0, import_react.forwardRef)((props, ref) => {
     contentSlot,
     virtualTriggering,
     virtualRef,
+    unmountOnExit = true,
     ...rest
   } = props;
   const [popperProps] = (0, import_hooks.partitionPopperPropsUtils)(rest);
@@ -193,8 +182,8 @@ var Tooltip = (0, import_react.forwardRef)((props, ref) => {
       },
       onMouseEnter: enterable && trigger === "hover" ? handleMouseEnter : import_noop.default,
       onMouseLeave: enterable && trigger === "hover" ? handleMouseLeave : import_noop.default,
-      className: (0, import_classnames.default)(is(theme), props.popperClass, { [e`popper`]: classPrefix === "tooltip" }),
-      unmountOnExit: props.unmountOnExit,
+      className: (0, import_classnames.default)(is(effect), props.popperClass, { [e`popper`]: classPrefix === "tooltip" }),
+      unmountOnExit,
       ...popperProps,
       ...transitionProps
     },

package/dist/Tooltip/TooltipContext.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 export interface TooltipContextProps {
     onMouseEnter?: (e?: React.MouseEvent<any>) => void;
     onMouseLeave?: (e?: React.MouseEvent<any>) => void;
+    /** 触发下拉的行为 */
     trigger: 'hover' | 'click' | 'contextmenu';
     onClose: () => void;
 }

package/dist/Tooltip/typings.d.ts

@@ -11,21 +11,34 @@ export type TooltipRef = {
     hide: () => void;
 };
 export interface TooltipProps extends BaseProps<React.ReactNode>, NativeProps, PopperOptions, AnimationEventProps, Omit<TransitionProps, 'children'> {
+    /** class 前缀 */
     classPrefix?: string;
+    /** 指示 Tooltip 的内容将附加在哪一个网页元素上 */
     appendTo?: HTMLElement;
-    effect?: 'light' | 'dark';
+    /** 默认提供的主题 */
+    effect?: 'light' | 'dark' | string;
+    /** 显示的内容 */
     content?: string | React.ReactNode;
+    /** 触发下拉的行为 */
     trigger?: 'hover' | 'click' | 'contextmenu';
+    /** 状态是否可见 */
     visible?: boolean;
+    /** 初始值 */
     defaultVisible?: boolean;
+    /** Tooltip 是否可用 */
     disabled?: boolean;
+    /** 鼠标是否可进入到 tooltip 中 */
     enterable?: boolean;
+    /** 延迟出现，单位毫秒 */
     showAfter?: number;
+    /** Tooltip 出现后自动隐藏延时，单位毫秒，为 0 则不会自动隐藏 */
     hideAfter?: number;
     onMouseEnter?: (e?: React.MouseEvent<any>) => void;
     onMouseLeave?: (e?: React.MouseEvent<any>) => void;
     triggerRef?: React.ReactElement;
+    /** 用来标识虚拟触发是否被启用 */
     virtualTriggering?: boolean;
+    /** 标识虚拟触发时的触发元素 */
     virtualRef?: VirtualElement;
     contentSlot?: ComponentChildren;
 }

package/dist/Transfer/ListItem.d.ts

@@ -9,6 +9,7 @@ type ListItemProps<RecordType> = {
     onClick: (item: RecordType) => void;
     onRemove?: (item: RecordType) => void;
     item: RecordType;
+    /** 数据源的字段别名 */
     fieldNames: FieldNames;
 };
 declare const ListItem: <RecordType extends KeyWiseTransferItem>(props: ListItemProps<RecordType>) => React.JSX.Element;

package/dist/Transfer/typings/index.d.ts

@@ -20,6 +20,7 @@ export type TransferRender<RecordType> = (item: RecordType) => RenderResult;
 export interface ListStyle {
     direction: TransferDirection;
 }
+/** 自定义顶部多选框标题的集合 */
 export type SelectAllLabel = React.ReactElement<any> | ((info: {
     selectedCount: number;
     totalCount: number;
@@ -39,32 +40,58 @@ export interface TransferLocale {
     removeCurrent?: string;
 }
 export interface TransferProps<RecordType extends TransferItem = TransferItem> extends Omit<BaseProps, 'children'>, NativeProps {
+    /** 是否禁用 */
     disabled?: boolean;
+    /** 数据源，其中的数据将会被渲染到左边一栏中，targetKeys 中指定的除外 */
     data: RecordType[];
+    /** 默认显示在右侧框数据的 key 集合 */
     defaultValue?: (string | number)[];
+    /** 显示在右侧框数据的 key 集合（控制模式） */
     value?: (string | number)[];
+    /** 设置哪些项应该被选中 */
     selectedKeys?: (string | number)[];
+    /** 每行数据渲染函数，该函数的入参为 dataSource 中的项，返回值为 ReactElement。或者返回一个普通对象，其中 label 字段为 ReactElement，value 字段为 title */
     render?: TransferRender<RecordType>;
+    /** 选项在两栏之间转移时的回调函数 */
     onChange?: (targetKeys: (string | number)[], direction: TransferDirection, moveKeys: (string | number)[]) => void;
+    /** 选中项发生改变时的回调函数 */
     onSelectChange?: (sourceSelectedKeys: (string | number)[], targetSelectedKeys: (string | number)[]) => void;
+    /** 两个穿梭框的自定义样式 */
     listStyle?: ((style: ListStyle) => React.CSSProperties) | React.CSSProperties;
+    /** 操作栏的自定义样式 */
     operationStyle?: React.CSSProperties;
+    /** 标题集合，顺序从左至右 */
     titles?: (React.ReactElement | string)[];
+    /** 操作文案集合，顺序从上至下 */
     operations?: string[];
+    /** 是否显示搜索框 */
     filterable?: boolean;
+    /** 接收 inputValue option 两个参数，当 option 符合筛选条件时，应返回 true，反之则返回 false */
     filterMethod?: (inputValue: string, item: RecordType) => boolean;
+    /**  */
     locale?: Partial<TransferLocale>;
+    /** 底部渲染函数 */
     footer?: (props: TransferListProps<RecordType>, extra: {
         direction: TransferDirection;
     }) => React.ReactElement;
+    /** 搜索框内容时改变时的回调函数 */
     onSearch?: (direction: TransferDirection, value: string) => void;
+    /** 选项列表滚动时的回调函数 */
     onScroll?: (direction: TransferDirection, e: any) => void;
+    /**  */
     children?: (props: TransferListBodyProps<RecordType>) => React.ReactElement;
+    /** 是否展示全选勾选框 */
     showSelectAll?: boolean;
+    /** 自定义顶部多选框标题的集合 */
     selectAllLabels?: SelectAllLabel[];
+    /** 展示为单向样式 */
     oneWay?: boolean;
+    /** 使用分页样式，自定义渲染列表下无效 */
     pagination?: PaginationType;
+    /** 数据源的字段别名 */
     fieldNames?: FieldNames;
+    /** 表单校验错误提示 */
     error?: boolean;
+    /** 表单校验警告提示 */
     warning?: boolean;
 }

package/dist/Transfer/typings/list.d.ts

@@ -10,30 +10,55 @@ export interface RenderedItem<RecordType> {
 }
 export type RenderListFunction<T> = (props: TransferListBodyProps<T>) => React.ReactElement;
 export interface TransferListProps<RecordType> extends TransferLocale, BaseProps, NativeProps {
+    /** 标题 */
     titleText?: string | React.ReactElement;
+    /** 数据源 */
     data: RecordType[];
+    /**  */
     filterOption?: (filterText: string, item: RecordType) => boolean;
+    /**  */
     checkedKeys: (string | number)[];
+    /**  */
     handleFilter: (e: any) => void;
+    /**  */
     onItemSelect: (key: string | number, check: boolean) => void;
+    /**  */
     onItemSelectAll: (data: (string | number)[], checkAll: boolean, overWrite?: boolean) => void;
+    /**  */
     onItemRemove?: (keys: (string | number)[]) => void;
+    /**  */
     handleClear: () => void;
+    /**  */
     render?: (item: RecordType) => RenderResult;
+    /**  */
     showSearch?: boolean;
+    /**  */
     searchPlaceholder?: string;
+    /**  */
     itemUnit?: string;
+    /**  */
     itemsUnit?: string;
+    /**  */
     renderList?: RenderListFunction<RecordType>;
+    /**  */
     footer?: (props: TransferListProps<RecordType>, info?: {
         direction: TransferDirection;
     }) => React.ReactElement;
+    /**  */
     onScroll: (e: any) => void;
+    /**  */
     disabled?: boolean;
+    /**  */
     direction: TransferDirection;
+    /** 是否展示全选勾选框 */
     showSelectAll?: boolean;
+    /**  */
+    /** 自定义顶部多选框标题 */
     selectAllLabel?: SelectAllLabel;
+    /**  */
     showRemove?: boolean;
+    /** 分页 */
     pagination?: PaginationType;
+    /** 数据源的字段别名 */
     fieldNames: FieldNames;
 }

package/dist/Transfer/typings/listBody.d.ts

@@ -12,6 +12,7 @@ export interface TransferListBodyProps<RecordType> extends PartialTransferListPr
     filteredItems: RecordType[];
     filteredRenderItems: RenderedItem<RecordType>[];
     selectedKeys: (string | number)[];
+    /** 数据源的字段别名 */
     fieldNames: FieldNames;
 }
 export {};

package/dist/Transition/Transition.d.ts

@@ -14,17 +14,27 @@ interface ExtraProps {
 }
 export interface TransitionProps extends AnimationEventProps {
     animation?: boolean;
+    /** Primary content */
     children?: ComponentChildren;
+    /** Additional classes */
     className?: string;
     name?: string;
     display?: string;
+    /** Show the component; triggers the enter or exit animation */
     visible?: boolean;
+    /** Unmount the component (remove it from the DOM) when it is not shown */
     unmountOnExit?: boolean;
+    /** Run the enter animation when the component mounts, if it is initially shown */
     transitionAppear?: boolean;
+    /** A Timeout for the animation */
     duration?: number;
+    /** CSS class or classes applied when the component is exited */
     exitedClassName?: string;
+    /** CSS class or classes applied while the component is exiting */
     exitingClassName?: string;
+    /** CSS class or classes applied when the component is entered */
     enteredClassName?: string;
+    /** CSS class or classes applied while the component is entering */
     enteringClassName?: string;
 }
 interface TransitionState {

package/dist/Transition/TransitionGroup.d.ts

@@ -1,10 +1,55 @@
 import React, { Component } from 'react';
 export interface TransitionGroupProps {
+    /**
+     * `<TransitionGroup>` renders a `<div>` by default. You can change this
+     * behavior by providing a `component` prop.
+     * If you use React v16+ and would like to avoid a wrapping `<div>` element
+     * you can pass in `component={null}`. This is useful if the wrapping div
+     * borks your css styles.
+     */
     component: any;
+    /**
+     * A set of `<Transition>` components, that are toggled `in` and out as they
+     * leave. the `<TransitionGroup>` will inject specific transition props, so
+     * remember to spread them through if you are wrapping the `<Transition>` as
+     * with our `<Fade>` example.
+     *
+     * While this component is meant for multiple `Transition` or `CSSTransition`
+     * children, sometimes you may want to have a single transition child with
+     * content that you want to be transitioned out and in when you change it
+     * (e.g. routes, images etc.) In that case you can change the `key` prop of
+     * the transition child as you change its content, this will cause
+     * `TransitionGroup` to transition the child out and back in.
+     */
     children: React.ReactNode;
+    /**
+     * A convenience prop that enables or disables transitionAppear animations
+     * for all children. Note that specifying this will override any defaults set
+     * on individual children Transitions.
+     */
     transitionAppear: boolean;
+    /**
+     * A convenience prop that enables or disables enter animations
+     * for all children. Note that specifying this will override any defaults set
+     * on individual children Transitions.
+     */
     enter: boolean;
+    /**
+     * A convenience prop that enables or disables exit animations
+     * for all children. Note that specifying this will override any defaults set
+     * on individual children Transitions.
+     */
     exit: boolean;
+    /**
+     * You may need to apply reactive updates to a child as it is exiting.
+     * This is generally done by using `cloneElement` however in the case of an exiting
+     * child the element has already been removed and not accessible to the consumer.
+     *
+     * If you do need to update a child as it leaves you can provide a `childFactory`
+     * to wrap every child, even the ones that are leaving.
+     *
+     * @type Function(child: ReactElement) -> ReactElement
+     */
     childFactory: (child: React.ReactNode) => React.ReactNode;
 }
 interface State {
@@ -15,6 +60,20 @@ interface State {
     handleExited?: (child: any, node: any) => void;
     firstRender?: boolean;
 }
+/**
+ * The `<TransitionGroup>` component manages a set of transition components
+ * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition
+ * components, `<TransitionGroup>` is a state machine for managing the mounting
+ * and unmounting of components over time.
+ *
+ * Consider the example below. As items are removed or added to the TodoList the
+ * `in` prop is toggled automatically by the `<TransitionGroup>`.
+ *
+ * Note that `<TransitionGroup>`  does not define any animation behavior!
+ * Exactly _how_ a list item animates is up to the individual transition
+ * component. This means you can mix and match animations across different list
+ * items.
+ */
 declare class TransitionGroup extends Component<TransitionGroupProps, State> {
     mounted: boolean | undefined;
     static defaultProps: {

package/dist/Transition/childMapping.d.ts

@@ -1,5 +1,28 @@
 import React from 'react';
+/**
+ * Given `this.props.children`, return an object mapping key to child.
+ *
+ * @param {*} children `this.props.children`
+ * @return {object} Mapping of key to child
+ */
 export declare function getChildMapping(children: React.ReactElement<any>[] | React.ReactElement<any>, mapFn?: (child: React.ReactElement<any>) => React.ReactNode): any;
+/**
+ * When you're adding or removing children some may be added or removed in the
+ * same render pass. We want to show *both* since we want to simultaneously
+ * animate elements in and out. This function takes a previous set of keys
+ * and a new set of keys and merges them with its best guess of the correct
+ * ordering. In the future we may expose some of the utilities in
+ * ReactMultiChild to make this easy, but for now React itself does not
+ * directly have this concept of the union of prevChildren and nextChildren
+ * so we implement it here.
+ *
+ * @param {object} prev prev children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @param {object} next next children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @return {object} a key set that contains all keys in `prev` and all keys
+ * in `next` in a reasonable order.
+ */
 export declare function mergeChildMappings(prev: any, next: any): {};
 export declare function getInitialChildMapping(props: any, afterLeave: any): any;
 export declare function getNextChildMapping(nextProps: any, prevChildMapping: any, afterLeave: any): {};

package/dist/Tree/NodeList.d.ts

@@ -38,6 +38,9 @@ interface NodeListProps {
     onListChangeStart: () => void;
     onListChangeEnd: () => void;
 }
+/**
+ * We only need get visible content items to play the animation.
+ */
 export declare function getMinimumRangeTransitionRange(list: FlattenNode[], virtual: boolean, height: number, itemHeight: number): FlattenNode[];
 declare const NodeList: FC<NodeListProps>;
 export default NodeList;

package/dist/Tree/RCTree.d.ts

@@ -114,6 +114,10 @@ export interface TreeProps<TreeDataType extends BasicDataNode = DataNode> {
         dropPosition: number;
         dropToGap: boolean;
     }) => void;
+    /**
+     * Used for `rc-tree-select` only.
+     * Do not use in your production code directly since this will be refactor.
+     */
     onActiveChange?: (key: Key) => void;
     filterTreeNode?: (treeNode: EventDataNode) => boolean;
     motion?: any;
@@ -186,6 +190,13 @@ declare class RCTree<TreeDataType extends BasicDataNode = DataNode> extends Comp
     componentWillUnmount(): void;
     static getDerivedStateFromProps(props: TreeProps, prevState: TreeState): Partial<TreeState<DataNode<any>>>;
     onNodeDragStart: NodeDragEventHandler<HTMLDivElement, TreeDataType>;
+    /**
+     * [Legacy] Select handler is smaller than node,
+     * so that this will trigger when drag enter node or select handler.
+     * This is a little tricky if customize css without padding.
+     * Better for use mouse move event to refresh drag state.
+     * But let's just keep it to avoid event trigger logic change.
+     */
     onNodeDragEnter: (event: any, node: NodeInstance<TreeDataType>) => void;
     onNodeDragOver: (event: any, node: NodeInstance<TreeDataType>) => void;
     onNodeDragLeave: NodeDragEventHandler;
@@ -215,6 +226,7 @@ declare class RCTree<TreeDataType extends BasicDataNode = DataNode> extends Comp
         dropPosition: 0 | 1 | -1;
         keyEntities: Record<Key, DataEntity<TreeDataType>>;
     };
+    /** Set uncontrolled `expandedKeys`. This will also auto update `flattenNodes`. */
     setExpandedKeys: (expandedKeys: Key[]) => void;
     flattenTreeData: (expandedKeys: Key[]) => FlattenNode[];
     onNodeExpand: (e: any, treeNode: EventDataNode) => void;
@@ -224,6 +236,9 @@ declare class RCTree<TreeDataType extends BasicDataNode = DataNode> extends Comp
     getActiveItem: () => FlattenNode;
     offsetActiveKey: (offset: number) => void;
     onKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+    /**
+     * Only update the value which is not in props
+     */
     setUncontrolledState: (state: Partial<TreeState>, atomic?: boolean, forceState?: Partial<TreeState<TreeDataType>> | null) => void;
     scrollTo: ScrollTo;
     render(): React.JSX.Element;

package/dist/Tree/Tree.d.ts

@@ -84,25 +84,40 @@ export interface TreeProps<T> extends Omit<RcTreeProps<T>, 'prefixCls' | 'showLi
         showLeafIcon: boolean;
     };
     className?: string;
+    /** 是否支持多选 */
     multiple?: boolean;
+    /** 是否自动展开父节点 */
     autoExpandParent?: boolean;
+    /** Checkable状态下节点选择完全受控（父子节点选中状态不再关联） */
     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[];
+    /** 设置节点可拖拽（IE>8） */
     draggable?: DraggableFn | boolean | DraggableConfig;
     style?: React.CSSProperties;
     showIcon?: boolean;

package/dist/Tree/TreeNode.d.ts

@@ -18,16 +18,23 @@ export interface TreeNodeProps<TreeDataType extends BasicDataNode = DataNode> {
     dragOverGapBottom?: boolean;
     pos?: string;
     domRef?: Ref<HTMLDivElement>;
+    /** New added in Tree for easy data access */
     data?: TreeDataType;
     isStart?: boolean[];
     isEnd?: boolean[];
     active?: boolean;
     onMouseMove?: React.MouseEventHandler<HTMLDivElement>;
+    /** 设置为叶子节点 (设置了 loadData 时有效)。为 false 时会强制将其作为父节点 */
     isLeaf?: boolean;
+    /** 当树为 checkable 时，设置独立节点是否展示 Checkbox */
     checkable?: boolean;
+    /** 设置节点是否可被选中 */
     selectable?: boolean;
+    /** 禁掉响应 */
     disabled?: boolean;
+    /** 禁掉 checkbox */
     disableCheckbox?: boolean;
+    /** 自定义图标。可接收组件，props 为当前节点 props */
     icon?: IconType;
     switcherIcon?: IconType;
     children?: React.ReactElement;

package/dist/Tree/contextTypes.d.ts

@@ -1,4 +1,8 @@
 import React, { Context } from 'react';
+/**
+ * Webpack has bug for import loop, which is not the same behavior as ES module.
+ * When util.js imports the TreeNode for tree generate will cause treeContextTypes be empty.
+ */
 import { DraggableConfig } from './RCTree';
 import { BasicDataNode, DataEntity, DataNode, Direction, EventDataNode, IconType, Key, NodeInstance } from './typings';
 export type NodeMouseEventParams = {

package/dist/Tree/typings.d.ts

@@ -2,6 +2,7 @@ import React, { Component } from 'react';
 import { IconName } from '../Icon';
 import { TreeNodeProps } from './TreeNode';
 export { ScrollTo } from '../VirtualList';
+/** For fieldNames, we provides a abstract interface */
 export interface BasicDataNode {
     checkable?: boolean;
     disabled?: boolean;
@@ -10,6 +11,7 @@ export interface BasicDataNode {
     isLeaf?: boolean;
     selectable?: boolean;
     switcherIcon?: IconType;
+    /** Set style of TreeNode. This is not recommend if you don't have any force requirement */
     className?: string;
     style?: React.CSSProperties;
 }
@@ -72,6 +74,7 @@ export type GetCheckDisabled<RecordType> = (record: RecordType) => boolean;
 export type Direction = 'ltr' | 'rtl' | undefined;
 export interface FieldNames {
     title?: string;
+    /** @private Internal usage for `rc-tree-select`, safe to remove if no need */
     _title?: string[];
     key?: string;
     children?: string;

package/dist/Tree/util.d.ts

@@ -26,13 +26,30 @@ export declare function calcDropPosition<TreeDataType extends BasicDataNode = Da
     dragOverNodeKey: Key;
     dropAllowed: boolean;
 };
+/**
+ * Return selectedKeys according with multiple prop
+ * @param selectedKeys
+ * @param props
+ * @returns [string]
+ */
 export declare function calcSelectedKeys(selectedKeys: Key[], props: TreeProps): Key[];
 export declare function convertDataToTree(treeData: DataNode[], processor?: {
     processProps: (prop: DataNode) => any;
 }): NodeElement[];
+/**
+ * Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
+ */
 export declare function parseCheckedKeys(keys: Key[] | {
     checked: Key[];
     halfChecked: Key[];
 }): any;
+/**
+ * If user use `autoExpandParent` we should get the list of parent node
+ * @param keyList
+ * @param keyEntities
+ */
 export declare function conductExpandParent(keyList: Key[], keyEntities: Record<Key, DataEntity>): Key[];
+/**
+ * omit prop
+ */
 export declare function omit<T extends object, K extends keyof T>(obj: T, fields: K[]): Omit<T, K>;