@laser-ui/components 0.0.1

package/tree/internal/TreePanel.js

@@ -0,0 +1,167 @@
+import { __rest } from "tslib";
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEventCallback } from '@laser-ui/hooks';
+import { scrollIntoViewIfNeeded } from '@laser-ui/utils';
+import { ReactComponent as AddBoxOutlined } from '@material-design-icons/svg/outlined/add_box.svg';
+import { ReactComponent as ArrowRightOutlined } from '@material-design-icons/svg/outlined/arrow_right.svg';
+import { ReactComponent as IndeterminateCheckBoxOutlined } from '@material-design-icons/svg/outlined/indeterminate_check_box.svg';
+import { isUndefined } from 'lodash';
+import { cloneElement, forwardRef, useImperativeHandle, useMemo, useRef } from 'react';
+import { Checkbox } from '../../checkbox';
+import { Empty } from '../../empty';
+import { useTranslation } from '../../hooks';
+import { Icon } from '../../icon';
+import { CircularProgress } from '../../internal/circular-progress';
+import { CollapseTransition } from '../../internal/transition';
+import { mergeCS } from '../../utils';
+import { TTANSITION_DURING_BASE } from '../../vars';
+import { VirtualScroll } from '../../virtual-scroll';
+function TreePanelFC(props, ref) {
+    var _a, _b;
+    const { namespace, styled, list, itemId, itemSelected, itemFocused, expands, customItem, showLine, multiple, onlyLeafSelectable, disabled, virtual, focusVisible, onNodeFocus, onNodeExpand, onNodeClick, onScrollBottom } = props, restProps = __rest(props, ["namespace", "styled", "list", "itemId", "itemSelected", "itemFocused", "expands", "customItem", "showLine", "multiple", "onlyLeafSelectable", "disabled", "virtual", "focusVisible", "onNodeFocus", "onNodeExpand", "onNodeClick", "onScrollBottom"]);
+    const { t } = useTranslation();
+    const listRef = useRef(null);
+    const vsRef = useRef(null);
+    const handleKeyDown = useEventCallback((code) => {
+        var _a, _b, _c, _d, _e, _f;
+        if (listRef.current) {
+            let item;
+            if (itemFocused) {
+                const isExpand = expands.has(itemFocused.id);
+                switch (code) {
+                    case 'next':
+                        item = (_a = vsRef.current) === null || _a === void 0 ? void 0 : _a.scrollToStep(listRef.current, 1);
+                        break;
+                    case 'prev':
+                        item = (_b = vsRef.current) === null || _b === void 0 ? void 0 : _b.scrollToStep(listRef.current, -1);
+                        break;
+                    case 'first':
+                        item = (_c = vsRef.current) === null || _c === void 0 ? void 0 : _c.scrollToStart(listRef.current);
+                        break;
+                    case 'last':
+                        item = (_d = vsRef.current) === null || _d === void 0 ? void 0 : _d.scrollToEnd(listRef.current);
+                        break;
+                    case 'prev-level':
+                        if (!itemFocused.isLeaf && isExpand) {
+                            onNodeExpand(itemFocused);
+                        }
+                        else if (itemFocused.parent) {
+                            item = (_e = vsRef.current) === null || _e === void 0 ? void 0 : _e.scrollToItem(listRef.current, itemFocused.parent.id);
+                        }
+                        break;
+                    case 'next-level':
+                        if (!itemFocused.isLeaf) {
+                            if (isExpand) {
+                                item = (_f = vsRef.current) === null || _f === void 0 ? void 0 : _f.scrollToNested(listRef.current);
+                            }
+                            else {
+                                onNodeExpand(itemFocused);
+                            }
+                        }
+                        break;
+                    default:
+                        if (code instanceof HTMLElement && listRef.current) {
+                            scrollIntoViewIfNeeded(code, listRef.current);
+                        }
+                        break;
+                }
+            }
+            return item;
+        }
+    });
+    useImperativeHandle(ref, () => handleKeyDown, [handleKeyDown]);
+    const vsProps = useMemo(() => {
+        var _a;
+        return ({
+            list,
+            itemKey: (item) => item.id,
+            itemSize: (_a = virtual === null || virtual === void 0 ? void 0 : virtual.itemSize) !== null && _a !== void 0 ? _a : 32,
+            itemEmptySize: 32,
+            itemNested: (item) => item.children,
+            itemFocusable: (item) => item.enabled,
+            itemExpand: (item) => (item.children ? expands.has(item.id) : undefined),
+        });
+    }, [expands, list, virtual]);
+    return (_jsx(VirtualScroll, Object.assign({}, vsProps, { ref: vsRef, enable: !isUndefined(virtual), listSize: (_a = virtual === null || virtual === void 0 ? void 0 : virtual.listSize) !== null && _a !== void 0 ? _a : 0, listPadding: (_b = virtual === null || virtual === void 0 ? void 0 : virtual.listPadding) !== null && _b !== void 0 ? _b : 0, itemRender: (item, index, props, ancestry, children) => {
+            if (item.children) {
+                const isExpand = expands.has(item.id);
+                let isSelectedAncestry = false;
+                if (item.children && itemSelected) {
+                    let node = itemSelected;
+                    while (node.parent) {
+                        node = node.parent;
+                        if (node.id === item.id) {
+                            isSelectedAncestry = true;
+                            break;
+                        }
+                    }
+                }
+                return (_createElement("li", Object.assign({}, styled('tree__group', {
+                    'tree__group--root': props['aria-level'] === 1,
+                }), props, { key: item.id, role: "treeitem", "aria-expanded": isExpand, "aria-selected": item.checked, "aria-disabled": item.disabled }),
+                    _jsxs("div", Object.assign({}, styled('tree__option', {
+                        'tree__option.is-selected': !multiple && item.checked,
+                        'tree__option.is-disabled': item.disabled,
+                        'tree__option--root': props['aria-level'] === 1,
+                        'tree__option--first': index === 0,
+                    }), { id: itemId(item.id), title: item.origin.label, onClick: () => {
+                            onNodeFocus(item);
+                            if (multiple || onlyLeafSelectable) {
+                                onNodeExpand(item);
+                            }
+                            else {
+                                onNodeClick(item);
+                            }
+                        }, children: [focusVisible && (itemFocused === null || itemFocused === void 0 ? void 0 : itemFocused.id) === item.id && _jsx("div", { className: `${namespace}-focus-outline` }), isSelectedAncestry && _jsx("div", Object.assign({}, styled('tree__option-dot'))), _jsx("div", Object.assign({}, styled('tree__option-icon'), { onClick: (e) => {
+                                    e.stopPropagation();
+                                    onNodeFocus(item);
+                                    onNodeExpand(item);
+                                }, children: _jsx(Icon, { children: item.origin.loading ? (_jsx(CircularProgress, {})) : showLine ? (isExpand ? (_jsx(IndeterminateCheckBoxOutlined, {})) : (_jsx(AddBoxOutlined, {}))) : (_jsx(ArrowRightOutlined, Object.assign({}, styled('tree__option-arrow', {
+                                        'tree__option-arrow.is-expand': isExpand,
+                                    })))) }) })), multiple && (_jsx("div", Object.assign({}, styled('tree__option-checkbox'), { children: _jsx(Checkbox, { model: item.checked, disabled: item.disabled, indeterminate: item.indeterminate, inputRender: (el) => cloneElement(el, { tabIndex: -1 }), onClick: (e) => {
+                                        e.stopPropagation();
+                                        onNodeFocus(item);
+                                        onNodeClick(item);
+                                    } }) }))), _jsx("div", Object.assign({}, styled('tree__option-content'), { children: customItem ? customItem(item.origin) : item.origin.label }))] })),
+                    !item.origin.loading && (_jsx(CollapseTransition, { originalSize: {
+                            height: 'auto',
+                        }, collapsedSize: {
+                            height: 0,
+                        }, enter: isExpand, during: TTANSITION_DURING_BASE, styles: {
+                            entering: {
+                                transition: ['height', 'padding', 'margin'].map((attr) => `${attr} ${TTANSITION_DURING_BASE}ms ease-out`).join(', '),
+                            },
+                            leaving: {
+                                transition: ['height', 'padding', 'margin'].map((attr) => `${attr} ${TTANSITION_DURING_BASE}ms ease-in`).join(', '),
+                            },
+                            leaved: { display: 'none' },
+                        }, children: (listRef, collapseStyle) => (_jsx("ul", Object.assign({}, mergeCS(styled('tree__group'), {
+                            style: collapseStyle,
+                        }), { ref: listRef, role: "group", "aria-labelledby": itemId(item.id), children: children }))) }))));
+            }
+            return (_createElement("li", Object.assign({}, styled('tree__option', {
+                'tree__option.is-selected': !multiple && item.checked,
+                'tree__option.is-disabled': item.disabled,
+                'tree__option--root': props['aria-level'] === 1,
+                'tree__option--first': index === 0,
+            }), props, { key: item.id, id: itemId(item.id), title: item.origin.label, role: "treeitem", "aria-selected": item.checked, "aria-disabled": item.disabled, onClick: () => {
+                    onNodeFocus(item);
+                    onNodeClick(item);
+                } }),
+                focusVisible && (itemFocused === null || itemFocused === void 0 ? void 0 : itemFocused.id) === item.id && _jsx("div", { className: `${namespace}-focus-outline` }),
+                multiple && (_jsx("div", Object.assign({}, styled('tree__option-checkbox'), { children: _jsx(Checkbox, { model: item.checked, disabled: item.disabled, indeterminate: item.indeterminate, inputRender: (el) => cloneElement(el, { tabIndex: -1 }), onClick: (e) => {
+                            e.stopPropagation();
+                            onNodeFocus(item);
+                            onNodeClick(item);
+                        } }) }))),
+                _jsx("div", Object.assign({}, styled('tree__option-content'), { children: customItem ? customItem(item.origin) : item.origin.label }))));
+        }, itemFocused: itemFocused === null || itemFocused === void 0 ? void 0 : itemFocused.id, itemEmptyRender: () => (_jsx("li", Object.assign({}, styled('tree__empty'), { children: _jsx("div", Object.assign({}, styled('tree__option-content'), { children: t('No Data') })) }))), itemInAriaSetsize: (item) => !item.children, placeholder: "li", onScrollEnd: onScrollBottom, children: (vsList, onScroll) => (_jsx("ul", Object.assign({}, restProps, mergeCS(styled('tree', {
+            'tree.is-disabled': disabled,
+            'tree--line': showLine,
+        }), {
+            className: restProps.className,
+            style: restProps.style,
+        }), { ref: listRef, role: "tree", "aria-multiselectable": multiple, "aria-activedescendant": isUndefined(itemFocused) ? undefined : itemId(itemFocused.id), onScroll: onScroll, children: list.length === 0 ? _jsx(Empty, { style: { padding: '12px 28px' }, image: Empty.SIMPLE_IMG }) : vsList }))) })));
+}
+export const TreePanel = forwardRef(TreePanelFC);

package/tree/node/abstract-node.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import type { TreeNode, TreeNodeStatus } from './types';
+export declare abstract class AbstractTreeNode<ID extends React.Key, T extends TreeNode> {
+    origin: T;
+    private _parent;
+    constructor(origin: T);
+    get parent(): AbstractTreeNode<ID, T> | null;
+    get root(): AbstractTreeNode<ID, T>;
+    get isLeaf(): boolean;
+    get id(): ID;
+    get status(): TreeNodeStatus;
+    get checked(): boolean;
+    get unchecked(): boolean;
+    get indeterminate(): boolean;
+    get disabled(): boolean;
+    get enabled(): boolean;
+    updateStatus(checked: ID | null | Set<ID>, onlySelf?: boolean): void;
+    protected _setParent(parent: AbstractTreeNode<ID, T>): void;
+    protected _updateAncestors(checked: ID | null | Set<ID>, onlySelf: boolean): void;
+    abstract children?: AbstractTreeNode<ID, T>[];
+    protected abstract _id: ID;
+    protected abstract _status: TreeNodeStatus;
+    protected abstract _disabled: boolean;
+    protected abstract _calculateStatus(checked: ID | null | Set<ID>): void;
+}

package/tree/node/abstract-node.js

@@ -0,0 +1,68 @@
+import { CHECKED, INDETERMINATE, UNCHECKED } from './vars';
+export class AbstractTreeNode {
+    constructor(origin) {
+        Object.defineProperty(this, "origin", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: origin
+        });
+        Object.defineProperty(this, "_parent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    get parent() {
+        return this._parent;
+    }
+    get root() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let node = this;
+        while (node.parent) {
+            node = node.parent;
+        }
+        return node;
+    }
+    get isLeaf() {
+        return !this.children;
+    }
+    get id() {
+        return this._id;
+    }
+    get status() {
+        return this._status;
+    }
+    get checked() {
+        return this._status === CHECKED;
+    }
+    get unchecked() {
+        return this._status === UNCHECKED;
+    }
+    get indeterminate() {
+        return this._status === INDETERMINATE;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    get enabled() {
+        return !this._disabled;
+    }
+    updateStatus(checked, onlySelf = false) {
+        if (this.children && !onlySelf) {
+            this.children.forEach((child) => {
+                child.updateStatus(checked, onlySelf);
+            });
+        }
+        this._calculateStatus(checked);
+    }
+    _setParent(parent) {
+        this._parent = parent;
+    }
+    _updateAncestors(checked, onlySelf) {
+        if (this._parent && !onlySelf) {
+            this._parent.updateStatus(checked, onlySelf);
+        }
+    }
+}

package/tree/node/multiple-node.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import type { TreeNode, TreeNodeStatus } from './types';
+import { AbstractTreeNode } from './abstract-node';
+export declare class MultipleTreeNode<ID extends React.Key, T extends TreeNode> extends AbstractTreeNode<ID, T> {
+    private getId;
+    private opts;
+    children?: MultipleTreeNode<ID, T>[];
+    protected _id: ID;
+    protected _status: TreeNodeStatus;
+    protected _disabled: boolean;
+    constructor(origin: T, getId: (origin: T) => ID, opts: {
+        disabled?: boolean;
+    });
+    changeStatus(status: TreeNodeStatus, checkeds: Set<ID>): Set<ID>;
+    protected _calculateStatus(checkeds: Set<ID>): void;
+    protected _changeStatus(status: TreeNodeStatus, initValue: Set<ID>): Set<ID>;
+    private _setUpChildren;
+}

package/tree/node/multiple-node.js

@@ -0,0 +1,109 @@
+import { AbstractTreeNode } from './abstract-node';
+import { CHECKED, INDETERMINATE, UNCHECKED } from './vars';
+export class MultipleTreeNode extends AbstractTreeNode {
+    constructor(origin, getId, opts) {
+        super(origin);
+        Object.defineProperty(this, "getId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getId
+        });
+        Object.defineProperty(this, "opts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: opts
+        });
+        Object.defineProperty(this, "children", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_disabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._id = getId(origin);
+        this._disabled = !!(opts.disabled || origin.disabled);
+        this._setUpChildren();
+    }
+    changeStatus(status, checkeds) {
+        const newCheckeds = this._changeStatus(status, checkeds);
+        return newCheckeds;
+    }
+    _calculateStatus(checkeds) {
+        if (this.children) {
+            let checkedNum = 0;
+            let hasIndeterminate = false;
+            let enabledLength = 0;
+            for (const child of this.children) {
+                if (child.enabled) {
+                    enabledLength += 1;
+                }
+                if (child.checked) {
+                    checkedNum += 1;
+                }
+                else if (child.enabled && child.indeterminate) {
+                    hasIndeterminate = true;
+                }
+            }
+            this._status = hasIndeterminate
+                ? INDETERMINATE
+                : checkedNum === 0
+                    ? UNCHECKED
+                    : checkedNum === enabledLength
+                        ? CHECKED
+                        : INDETERMINATE;
+        }
+        else {
+            this._status = checkeds.has(this._id) ? CHECKED : UNCHECKED;
+        }
+    }
+    _changeStatus(status, initValue) {
+        let res = new Set(initValue);
+        if (this.enabled && this._status !== status) {
+            this._status = status;
+            if (this.children) {
+                this.children.forEach((child) => {
+                    res = child._changeStatus(status, res);
+                });
+            }
+            else {
+                if (status === CHECKED) {
+                    res.add(this._id);
+                }
+                else {
+                    res.delete(this._id);
+                }
+            }
+        }
+        return res;
+    }
+    _setUpChildren() {
+        if (this.origin.children) {
+            this.children = this.origin.children.map((child) => {
+                const node = new MultipleTreeNode(child, this.getId, Object.assign(this.opts, {
+                    disabled: this._disabled,
+                }));
+                node._setParent(this);
+                return node;
+            });
+        }
+    }
+}

package/tree/node/single-node.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import type { TreeNode, TreeNodeStatus } from './types';
+import { AbstractTreeNode } from './abstract-node';
+export declare class SingleTreeNode<ID extends React.Key, T extends TreeNode> extends AbstractTreeNode<ID, T> {
+    private getId;
+    private opts;
+    children?: SingleTreeNode<ID, T>[];
+    protected _id: ID;
+    protected _status: TreeNodeStatus;
+    protected _disabled: boolean;
+    constructor(origin: T, getId: (origin: T) => ID, opts: {
+        disabled?: boolean;
+    });
+    private _setUpChildren;
+    protected _calculateStatus(checked: ID | null): void;
+}

package/tree/node/single-node.js

@@ -0,0 +1,60 @@
+import { AbstractTreeNode } from './abstract-node';
+import { CHECKED, UNCHECKED } from './vars';
+export class SingleTreeNode extends AbstractTreeNode {
+    constructor(origin, getId, opts) {
+        super(origin);
+        Object.defineProperty(this, "getId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getId
+        });
+        Object.defineProperty(this, "opts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: opts
+        });
+        Object.defineProperty(this, "children", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_disabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._id = getId(origin);
+        this._disabled = !!(opts.disabled || origin.disabled);
+        this._setUpChildren();
+    }
+    _setUpChildren() {
+        if (this.origin.children) {
+            this.children = this.origin.children.map((child) => {
+                const node = new SingleTreeNode(child, this.getId, Object.assign(this.opts, {
+                    disabled: this._disabled,
+                }));
+                node._setParent(this);
+                return node;
+            });
+        }
+    }
+    _calculateStatus(checked) {
+        this._status = this.id === checked ? CHECKED : UNCHECKED;
+    }
+}

package/tree/node/types.d.ts

@@ -0,0 +1,6 @@
+export {};
+export interface TreeNode {
+    disabled?: boolean;
+    children?: TreeNode[];
+}
+export type TreeNodeStatus = 'INDETERMINATE' | 'CHECKED' | 'UNCHECKED';

package/tree/node/types.js

@@ -0,0 +1 @@
+export {};

package/tree/node/vars.d.ts

@@ -0,0 +1,2 @@
+import type { TreeNodeStatus } from './types';
+export declare const INDETERMINATE: TreeNodeStatus, CHECKED: TreeNodeStatus, UNCHECKED: TreeNodeStatus;

package/tree/node/vars.js

@@ -0,0 +1 @@
+export const [INDETERMINATE, CHECKED, UNCHECKED] = ['INDETERMINATE', 'CHECKED', 'UNCHECKED'];

package/tree/types.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="react" />
+import type { CLASSES } from './vars';
+import type { FormControlProvider } from '../form/types';
+import type { BaseProps } from '../types';
+export {};
+export interface TreeItem<V extends React.Key> {
+    label: string;
+    value: V;
+    loading?: boolean;
+    disabled?: boolean;
+    children?: TreeItem<V>[];
+}
+export interface TreeProps<V extends React.Key, T extends TreeItem<V>> extends BaseProps<'tree', typeof CLASSES>, Omit<React.HTMLAttributes<HTMLUListElement>, 'children'> {
+    formControl?: FormControlProvider;
+    list: T[];
+    model?: V | null | V[];
+    defaultModel?: V | null | V[];
+    expands?: V[];
+    defaultExpands?: V[];
+    showLine?: boolean;
+    multiple?: boolean;
+    onlyLeafSelectable?: boolean;
+    disabled?: boolean;
+    virtual?: {
+        listSize: number;
+        listPadding: number;
+        itemSize?: number;
+    };
+    customItem?: (item: T) => React.ReactNode;
+    onModelChange?: (value: any, origin: any) => void;
+    onFirstExpand?: (value: V, origin: T) => void;
+    onExpandsChange?: (values: V[], origins: T[]) => void;
+    onScrollBottom?: () => void;
+}

package/tree/types.js

@@ -0,0 +1 @@
+export {};

package/tree/utils.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { AbstractTreeNode } from './node/abstract-node';
+import type { TreeNode } from './node/types';
+export declare function getTreeNodeLabel<V extends React.Key, T extends TreeNode & {
+    label: string;
+}>(node: AbstractTreeNode<V, T>): string;

package/tree/utils.js

@@ -0,0 +1,9 @@
+export function getTreeNodeLabel(node) {
+    const text = [node.origin.label];
+    let n = node;
+    while (n.parent) {
+        n = n.parent;
+        text.unshift(n.origin.label);
+    }
+    return text.join(' / ');
+}

package/tree/vars.d.ts

@@ -0,0 +1,20 @@
+export declare const CLASSES: {
+    tree: string;
+    'tree.is-disabled': string;
+    'tree--line': string;
+    tree__group: string;
+    'tree__group--root': string;
+    tree__option: string;
+    'tree__option.is-selected': string;
+    'tree__option.is-disabled': string;
+    'tree__option--root': string;
+    'tree__option--first': string;
+    'tree__option-dot': string;
+    'tree__option-icon': string;
+    'tree__option-arrow': string;
+    'tree__option-arrow.is-expand': string;
+    'tree__option-checkbox': string;
+    'tree__option-content': string;
+    tree__empty: string;
+};
+export declare const TREE_NODE_KEY: unique symbol;

package/tree/vars.js

@@ -0,0 +1,20 @@
+export const CLASSES = {
+    tree: '^tree',
+    'tree.is-disabled': 'is-disabled',
+    'tree--line': '^tree--line',
+    tree__group: '^tree__group',
+    'tree__group--root': '^tree__group--root',
+    tree__option: '^tree__option',
+    'tree__option.is-selected': 'is-selected',
+    'tree__option.is-disabled': 'is-disabled',
+    'tree__option--root': '^tree__option--root',
+    'tree__option--first': '^tree__option--first',
+    'tree__option-dot': '^tree__option-dot',
+    'tree__option-icon': '^tree__option-icon',
+    'tree__option-arrow': '^tree__option-arrow',
+    'tree__option-arrow.is-expand': 'is-expand',
+    'tree__option-checkbox': '^tree__option-checkbox',
+    'tree__option-content': '^tree__option-content',
+    tree__empty: '^tree__empty',
+};
+export const TREE_NODE_KEY = Symbol();

package/tree-select/TreeSelect.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { TreeSelectProps, TreeSelectRef } from './types';
+import type { TreeItem } from '../tree/types';
+declare function TreeSelectFC<V extends React.Key, T extends TreeItem<V>>(props: TreeSelectProps<V, T>, ref: React.ForwardedRef<TreeSelectRef>): JSX.Element | null;
+export declare const TreeSelect: <ID extends React.Key, T extends TreeItem<ID>>(props: TreeSelectProps<ID, T> & React.RefAttributes<TreeSelectRef>) => ReturnType<typeof TreeSelectFC>;
+export {};