@qsxy/element-plus-react 1.0.2 → 2.0.0

package/dist/Tree/TreeNodeContent.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type Node from './model/node';
+import { RenderContentFunction } from './typings';
+interface Props {
+    node: Node;
+    renderContent: RenderContentFunction;
+}
+declare const TreeNodeContent: (props: Props) => React.JSX.Element | React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+export default TreeNodeContent;

package/dist/Tree/TreeNodeContent.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { useClassNames } from "../hooks";
+import Text from "../Text/Text";
+var TreeNodeContent = function TreeNodeContent(props) {
+  // props = mergeDefaultProps({ node: {} as Node }, props);
+  var _props$node = props.node,
+    node = _props$node === void 0 ? {} : _props$node;
+  var _useClassNames = useClassNames('tree'),
+    be = _useClassNames.be;
+  var data = node.data,
+    store = node.store;
+  return props.renderContent ? props.renderContent({
+    _self: null,
+    node: node,
+    data: data,
+    store: store
+  }) : /*#__PURE__*/React.createElement(Text, {
+    className: be('node', 'label'),
+    truncated: true
+  }, node.label);
+};
+export default TreeNodeContent;

package/dist/Tree/index.d.ts

@@ -1,9 +1,4 @@
-export { default as DirectoryTree } from './DirectoryTree';
-export type { ExpandAction as DirectoryTreeExpandAction, DirectoryTreeProps } from './DirectoryTree';
-export { default as RCTree } from './RCTree';
-export type { CheckInfo } from './RCTree';
+export type { default as TreeNode } from './model/node';
+export type { default as TreeStore } from './model/tree-store';
 export { default as Tree } from './Tree';
-export type { TreeProps } from './Tree';
-export { default as TreeNode } from './TreeNode';
-export type { TreeNodeProps } from './TreeNode';
-export type { BasicDataNode, DataNode, EventDataNode, Key } from './typings';
+export type { AllowDragFunction, AllowDropFunction, AllowDropType, FilterNodeMethodFunction, LoadFunction, NodeDropType, TreeNodeData, TreeNodeProps, TreeOptionProps, TreeProps, TreeRef, } from './typings';

package/dist/Tree/index.js

@@ -1,4 +1 @@
-export { default as DirectoryTree } from "./DirectoryTree";
-export { default as RCTree } from "./RCTree";
-export { default as Tree } from "./Tree";
-export { default as TreeNode } from "./TreeNode";
+export { default as Tree } from "./Tree";

package/dist/Tree/model/node.d.ts

@@ -0,0 +1,62 @@
+import { FakeNode, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions } from '../typings';
+import TreeStore from './tree-store';
+export declare const getChildState: (node: Node[]) => TreeNodeChildState;
+declare class Node {
+    id: number;
+    text: string | null;
+    checked: boolean;
+    indeterminate: boolean;
+    data: TreeNodeData;
+    expanded: boolean;
+    parent: Node | null;
+    visible: boolean;
+    isCurrent: boolean;
+    store: TreeStore;
+    isLeafByUser: boolean | undefined;
+    isLeaf: boolean | undefined;
+    canFocus: boolean;
+    level: number;
+    loaded: boolean;
+    childNodes: Node[];
+    loading: boolean;
+    /**
+     * Determines whether the current tree node is effectively checked.
+     *
+     * Rules:
+     * 1. A disabled leaf node is always considered checked.
+     * 2. A non-disabled leaf node reflects its actual checked state.
+     * 3. A non-leaf node is considered checked only when:
+     *    - All of its child nodes are effectively checked, and
+     *    - Each child follows the same evaluation rules:
+     *      - Disabled leaf nodes follow rule #1.
+     *      - Non-leaf child nodes are recursively evaluated under this rule (#3).
+     */
+    isEffectivelyChecked: boolean;
+    constructor(options: TreeNodeOptions);
+    initialize(): void;
+    setData(data: TreeNodeData): void;
+    get label(): string;
+    get key(): TreeKey | null | undefined;
+    get disabled(): boolean;
+    get nextSibling(): Node | null;
+    get previousSibling(): Node | null;
+    contains(target: Node, deep?: boolean): boolean;
+    remove(): void;
+    insertChild(child?: FakeNode | Node, index?: number, batch?: boolean): void;
+    insertBefore(child: FakeNode | Node, ref: Node): void;
+    insertAfter(child: FakeNode | Node, ref: Node): void;
+    removeChild(child: Node): void;
+    removeChildByData(data: TreeNodeData | null): void;
+    expand(callback?: (() => void) | null, expandParent?: boolean): void;
+    doCreateChildren(array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps): void;
+    collapse(): void;
+    shouldLoadData(): boolean;
+    updateLeafState(): void;
+    setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void;
+    getChildren(forceInit?: boolean): TreeNodeData | TreeNodeData[] | null;
+    updateChildren(): void;
+    loadData(callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps): void;
+    eachNode(callback: (node: Node) => void): void;
+    reInitChecked(): void;
+}
+export default Node;