niuma-ui 1.3.9 → 2.0.1

package/dist/components/tree/src/RsTree.js

@@ -0,0 +1,8 @@
+import './RsTree.css'
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.js";
+import RsTree_vue_vue_type_script_setup_true_lang_default from "./RsTree.impl.js";
+
+//#region src/components/tree/src/RsTree.vue
+var RsTree_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsTree_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-59bbd9de"]]);
+//#endregion
+export { RsTree_default as default };

package/dist/components/tree/src/tree-utils.d.ts

@@ -0,0 +1,112 @@
+import type { RsComponentSize } from '../../../theme/types';
+export interface RsTreeNode {
+    key?: string;
+    id?: string;
+    label?: string;
+    title?: string;
+    children?: RsTreeNode[];
+    disabled?: boolean;
+    isLeaf?: boolean;
+    icon?: string;
+    disableCheckbox?: boolean;
+    loading?: boolean;
+    [key: string]: unknown;
+}
+export interface RsTreeFieldNames {
+    key?: string;
+    label?: string;
+    children?: string;
+    disabled?: string;
+    isLeaf?: string;
+    icon?: string;
+    disableCheckbox?: string;
+    loading?: string;
+}
+export interface RsTreeFlatNode {
+    key: string;
+    node: RsTreeNode;
+    depth: number;
+    hasChildren: boolean;
+    isLast: boolean;
+    parentKey: string | null;
+    /**
+     * showLine 用：下标对应祖先深度 `0..depth-1`。
+     * `true` 表示该祖先不是同级最后一项，竖线需贯穿当前行；`false` 则留空缺口。
+     */
+    levelLines: boolean[];
+}
+export interface RsTreeNodeIndex {
+    node: RsTreeNode;
+    parentKey: string | null;
+    childrenKeys: string[];
+}
+export type RsTreeCheckState = 'checked' | 'indeterminate' | 'unchecked';
+export type RsTreeFocusMove = 'next' | 'prev' | 'parent' | 'first' | 'last';
+export type RsTreeDropPosition = 'before' | 'inside' | 'after';
+/** handle=显示拖拽手柄；row=整行拖拽且不显示手柄 */
+export type RsTreeDragTrigger = 'handle' | 'row';
+export type RsTreeSize = RsComponentSize;
+export declare const DEFAULT_TREE_FIELD_NAMES: Required<RsTreeFieldNames>;
+/**
+ * 各尺寸档行高 / 缩进。
+ * 显式标注 Record<RsTreeSize, number>：尺寸类型再加档位时这里会直接编译报错，
+ * 而不是在运行时取到 undefined —— 行高 undefined 会让虚拟滚动的 padding 全变 NaN。
+ */
+export declare const TREE_ROW_HEIGHT: Record<RsTreeSize, number>;
+export declare const TREE_INDENT_BY_SIZE: Record<RsTreeSize, number>;
+export declare function resolveTreeFieldNames(fieldNames?: RsTreeFieldNames): Required<RsTreeFieldNames>;
+export declare function resolveTreeRowHeight(size?: RsTreeSize, custom?: number): number;
+export declare function resolveTreeIndent(size?: RsTreeSize): number;
+export declare function getTreeKey(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): string;
+export declare function getTreeLabel(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): string;
+export declare function getTreeChildren(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): RsTreeNode[];
+export declare function getTreeIsLeaf(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): boolean;
+export declare function isTreeNodeDisabled(node: RsTreeNode, fields?: Required<RsTreeFieldNames>): boolean;
+export declare function isTreeCheckboxDisabled(node: RsTreeNode, fields?: Required<RsTreeFieldNames>, options?: {
+    onlyCheckLeaf?: boolean;
+    lazy?: boolean;
+}): boolean;
+export declare function shouldShowTreeCheckbox(node: RsTreeNode, fields?: Required<RsTreeFieldNames>, options?: {
+    onlyCheckLeaf?: boolean;
+    lazy?: boolean;
+}): boolean;
+export declare function isTreeNodeLoading(node: RsTreeNode, key: string, loadingKeys: ReadonlySet<string>, fields?: Required<RsTreeFieldNames>): boolean;
+export declare function hasTreeChildren(node: RsTreeNode, fields?: Required<RsTreeFieldNames>, lazy?: boolean): boolean;
+export declare function flattenTreeNodeIds(nodes: readonly RsTreeNode[], fields?: Required<RsTreeFieldNames>): string[];
+export declare function collectExpandableKeys(nodes: readonly RsTreeNode[], fields?: Required<RsTreeFieldNames>, lazy?: boolean): string[];
+export declare function buildTreeNodeIndex(nodes: readonly RsTreeNode[], fields?: Required<RsTreeFieldNames>, lazy?: boolean): Map<string, RsTreeNodeIndex>;
+export declare function collectDescendantKeys(key: string, index: ReadonlyMap<string, RsTreeNodeIndex>): string[];
+/**
+ * `ancestorKey` 是否为 `descendantKey` 的祖先。
+ * 沿 parentKey 上溯 O(depth)，比收集整棵子树再 includes 便宜得多（拖拽 dragover 每帧都要判一次）。
+ */
+export declare function isTreeAncestorKey(ancestorKey: string, descendantKey: string, index: ReadonlyMap<string, RsTreeNodeIndex>): boolean;
+export declare function collectHalfCheckedKeys(index: ReadonlyMap<string, RsTreeNodeIndex>, checkedKeys: ReadonlySet<string>, checkStrictly: boolean, onlyCheckLeaf?: boolean): string[];
+export declare function flattenVisibleTreeNodes(nodes: readonly RsTreeNode[], expandedKeys: ReadonlySet<string>, fields?: Required<RsTreeFieldNames>, lazy?: boolean, depth?: number, parentKey?: string | null, 
+/** 路径上各祖先是否为同级最后一项（长度 = depth） */
+ancestorIsLast?: readonly boolean[]): RsTreeFlatNode[];
+export declare function defaultTreeFilterNode(node: RsTreeNode, keyword: string, fields?: Required<RsTreeFieldNames>): boolean;
+export declare function filterTreeNodes(nodes: readonly RsTreeNode[], keyword: string, options?: {
+    fieldNames?: RsTreeFieldNames;
+    filterNode?: (node: RsTreeNode, keyword: string) => boolean;
+}): RsTreeNode[];
+export declare function splitTreeLabelHighlight(label: string, keyword: string): Array<{
+    text: string;
+    highlight: boolean;
+}>;
+export declare function resolveTreeCheckState(key: string, checkedKeys: ReadonlySet<string>, index: ReadonlyMap<string, RsTreeNodeIndex>, checkStrictly: boolean, onlyCheckLeaf?: boolean): RsTreeCheckState;
+export declare function toggleTreeCheck(key: string, checkedKeys: ReadonlySet<string>, index: ReadonlyMap<string, RsTreeNodeIndex>, checkStrictly: boolean, onlyCheckLeaf?: boolean): string[];
+export declare function resolveAccordionExpandedKeys(key: string, expandedKeys: readonly string[], index: ReadonlyMap<string, RsTreeNodeIndex>, rootKeys: readonly string[]): string[];
+export declare function resolveTreeFocusKey(flatNodes: readonly RsTreeFlatNode[], currentKey: string | null, move: RsTreeFocusMove, index: ReadonlyMap<string, RsTreeNodeIndex>): string | null;
+export declare function resolveTreeVirtualEnabled(options: {
+    virtual?: boolean;
+    flatCount: number;
+    virtualThreshold?: number;
+}): boolean;
+export declare function sliceVirtualTreeNodes(nodes: readonly RsTreeFlatNode[], scrollTop: number, viewportHeight: number, itemHeight: number, overscan?: number): {
+    nodes: RsTreeFlatNode[];
+    /** 切片首项在完整扁平列表中的下标，供 aria-posinset 等按 O(1) 定位 */
+    startIndex: number;
+    paddingTop: number;
+    paddingBottom: number;
+};

package/dist/components/tree/src/tree-utils.js

@@ -0,0 +1,310 @@
+//#region src/components/tree/src/tree-utils.ts
+var DEFAULT_TREE_FIELD_NAMES = {
+	key: "key",
+	label: "label",
+	children: "children",
+	disabled: "disabled",
+	isLeaf: "isLeaf",
+	icon: "icon",
+	disableCheckbox: "disableCheckbox",
+	loading: "loading"
+};
+/**
+* 各尺寸档行高 / 缩进。
+* 显式标注 Record<RsTreeSize, number>：尺寸类型再加档位时这里会直接编译报错，
+* 而不是在运行时取到 undefined —— 行高 undefined 会让虚拟滚动的 padding 全变 NaN。
+*/
+var TREE_ROW_HEIGHT = {
+	ssm: 24,
+	sm: 28,
+	md: 32,
+	lg: 40
+};
+var TREE_INDENT_BY_SIZE = {
+	ssm: 12,
+	sm: 16,
+	md: 20,
+	lg: 24
+};
+function resolveTreeFieldNames(fieldNames) {
+	return {
+		...DEFAULT_TREE_FIELD_NAMES,
+		...fieldNames
+	};
+}
+function resolveTreeRowHeight(size = "md", custom) {
+	if (custom !== void 0) return custom;
+	return TREE_ROW_HEIGHT[size];
+}
+function resolveTreeIndent(size = "md") {
+	return TREE_INDENT_BY_SIZE[size];
+}
+function readNodeField(node, field) {
+	return node[field];
+}
+function getTreeKey(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	const mapped = readNodeField(node, fields.key);
+	if (mapped !== void 0 && mapped !== null && mapped !== "") return String(mapped);
+	if (node.key !== void 0 && node.key !== "") return String(node.key);
+	if (node.id !== void 0 && node.id !== "") return String(node.id);
+	const label = readNodeField(node, fields.label) ?? node.label ?? node.title;
+	return String(label ?? "");
+}
+function getTreeLabel(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	const mapped = readNodeField(node, fields.label);
+	if (mapped !== void 0 && mapped !== null && mapped !== "") return String(mapped);
+	if (node.label !== void 0 && node.label !== "") return String(node.label);
+	if (node.title !== void 0 && node.title !== "") return String(node.title);
+	return getTreeKey(node, fields);
+}
+function getTreeChildren(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	const mapped = readNodeField(node, fields.children);
+	if (Array.isArray(mapped)) return mapped;
+	return node.children ?? [];
+}
+function getTreeIsLeaf(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return Boolean(readNodeField(node, fields.isLeaf) ?? node.isLeaf);
+}
+function isTreeNodeDisabled(node, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return Boolean(readNodeField(node, fields.disabled) ?? node.disabled);
+}
+function isTreeCheckboxDisabled(node, fields = DEFAULT_TREE_FIELD_NAMES, options = {}) {
+	if (isTreeNodeDisabled(node, fields)) return true;
+	if (options.onlyCheckLeaf && hasTreeChildren(node, fields, options.lazy ?? false)) return true;
+	return Boolean(readNodeField(node, fields.disableCheckbox) ?? node.disableCheckbox);
+}
+function shouldShowTreeCheckbox(node, fields = DEFAULT_TREE_FIELD_NAMES, options = {}) {
+	if (!options.onlyCheckLeaf) return true;
+	return !hasTreeChildren(node, fields, options.lazy ?? false);
+}
+function isTreeNodeLoading(node, key, loadingKeys, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return loadingKeys.has(key) || Boolean(readNodeField(node, fields.loading) ?? node.loading);
+}
+function hasTreeChildren(node, fields = DEFAULT_TREE_FIELD_NAMES, lazy = false) {
+	if (getTreeIsLeaf(node, fields)) return false;
+	if (getTreeChildren(node, fields).length > 0) return true;
+	return lazy;
+}
+function flattenTreeNodeIds(nodes, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return nodes.flatMap((node) => [getTreeKey(node, fields), ...flattenTreeNodeIds(getTreeChildren(node, fields), fields)]);
+}
+function collectExpandableKeys(nodes, fields = DEFAULT_TREE_FIELD_NAMES, lazy = false) {
+	const keys = [];
+	function walk(items) {
+		for (const node of items) {
+			const key = getTreeKey(node, fields);
+			if (hasTreeChildren(node, fields, lazy)) {
+				keys.push(key);
+				walk(getTreeChildren(node, fields));
+			}
+		}
+	}
+	walk(nodes);
+	return keys;
+}
+function buildTreeNodeIndex(nodes, fields = DEFAULT_TREE_FIELD_NAMES, lazy = false) {
+	const map = /* @__PURE__ */ new Map();
+	function walk(items, parentKey) {
+		for (const node of items) {
+			const key = getTreeKey(node, fields);
+			const childrenKeys = hasTreeChildren(node, fields, lazy) ? getTreeChildren(node, fields).map((child) => getTreeKey(child, fields)) : [];
+			map.set(key, {
+				node,
+				parentKey,
+				childrenKeys
+			});
+			if (getTreeChildren(node, fields).length > 0) walk(getTreeChildren(node, fields), key);
+		}
+	}
+	walk(nodes, null);
+	return map;
+}
+function collectDescendantKeys(key, index) {
+	const entry = index.get(key);
+	if (!entry) return [];
+	const result = [];
+	for (const childKey of entry.childrenKeys) result.push(childKey, ...collectDescendantKeys(childKey, index));
+	return result;
+}
+/**
+* `ancestorKey` 是否为 `descendantKey` 的祖先。
+* 沿 parentKey 上溯 O(depth)，比收集整棵子树再 includes 便宜得多（拖拽 dragover 每帧都要判一次）。
+*/
+function isTreeAncestorKey(ancestorKey, descendantKey, index) {
+	let parentKey = index.get(descendantKey)?.parentKey ?? null;
+	while (parentKey !== null) {
+		if (parentKey === ancestorKey) return true;
+		parentKey = index.get(parentKey)?.parentKey ?? null;
+	}
+	return false;
+}
+function collectHalfCheckedKeys(index, checkedKeys, checkStrictly, onlyCheckLeaf = false) {
+	if (checkStrictly && !onlyCheckLeaf) return [];
+	if (checkedKeys.size === 0) return [];
+	const half = [];
+	for (const key of index.keys()) if (resolveTreeCheckState(key, checkedKeys, index, checkStrictly, onlyCheckLeaf) === "indeterminate") half.push(key);
+	return half;
+}
+/** 根层节点无祖先竖线；共享同一个空数组，省去每个节点一次数组分配 */
+var NO_LEVEL_LINES = Object.freeze([]);
+function flattenVisibleTreeNodes(nodes, expandedKeys, fields = DEFAULT_TREE_FIELD_NAMES, lazy = false, depth = 0, parentKey = null, ancestorIsLast = []) {
+	const result = [];
+	function walk(items, currentDepth, currentParentKey, ancestors) {
+		const lastIndex = items.length - 1;
+		const levelLines = ancestors.length === 0 ? NO_LEVEL_LINES : ancestors.map((last) => !last);
+		for (let index = 0; index <= lastIndex; index += 1) {
+			const node = items[index];
+			const key = getTreeKey(node, fields);
+			const hasChildren = hasTreeChildren(node, fields, lazy);
+			const isLast = index === lastIndex;
+			result.push({
+				key,
+				node,
+				depth: currentDepth,
+				hasChildren,
+				isLast,
+				parentKey: currentParentKey,
+				levelLines
+			});
+			if (hasChildren && expandedKeys.has(key)) walk(getTreeChildren(node, fields), currentDepth + 1, key, [...ancestors, isLast]);
+		}
+	}
+	walk(nodes, depth, parentKey, ancestorIsLast);
+	return result;
+}
+function defaultTreeFilterNode(node, keyword, fields = DEFAULT_TREE_FIELD_NAMES) {
+	return getTreeLabel(node, fields).toLowerCase().includes(keyword.trim().toLowerCase());
+}
+function filterTreeNodes(nodes, keyword, options = {}) {
+	const fields = resolveTreeFieldNames(options.fieldNames);
+	const query = keyword.trim();
+	if (!query) return [...nodes];
+	const match = options.filterNode ?? ((node, value) => defaultTreeFilterNode(node, value, fields));
+	function filterNode(node) {
+		const children = getTreeChildren(node, fields);
+		const filteredChildren = children.map(filterNode).filter((item) => item !== null);
+		if (match(node, query)) return {
+			...node,
+			children
+		};
+		if (filteredChildren.length > 0) return {
+			...node,
+			children: filteredChildren
+		};
+		return null;
+	}
+	return nodes.map(filterNode).filter((item) => item !== null);
+}
+function splitTreeLabelHighlight(label, keyword) {
+	const query = keyword.trim();
+	if (!query) return [{
+		text: label,
+		highlight: false
+	}];
+	const lowerLabel = label.toLowerCase();
+	const lowerQuery = query.toLowerCase();
+	const index = lowerLabel.indexOf(lowerQuery);
+	if (index < 0) return [{
+		text: label,
+		highlight: false
+	}];
+	const parts = [];
+	if (index > 0) parts.push({
+		text: label.slice(0, index),
+		highlight: false
+	});
+	parts.push({
+		text: label.slice(index, index + query.length),
+		highlight: true
+	});
+	if (index + query.length < label.length) parts.push({
+		text: label.slice(index + query.length),
+		highlight: false
+	});
+	return parts;
+}
+function resolveTreeCheckState(key, checkedKeys, index, checkStrictly, onlyCheckLeaf = false) {
+	if (checkStrictly && !onlyCheckLeaf) return checkedKeys.has(key) ? "checked" : "unchecked";
+	if (checkedKeys.size === 0) return "unchecked";
+	const entry = index.get(key);
+	if (!entry || entry.childrenKeys.length === 0) return checkedKeys.has(key) ? "checked" : "unchecked";
+	const childStates = entry.childrenKeys.map((childKey) => resolveTreeCheckState(childKey, checkedKeys, index, checkStrictly, onlyCheckLeaf));
+	if (childStates.every((state) => state === "checked")) return "checked";
+	if (childStates.some((state) => state === "checked" || state === "indeterminate")) return "indeterminate";
+	return "unchecked";
+}
+function toggleTreeCheck(key, checkedKeys, index, checkStrictly, onlyCheckLeaf = false) {
+	const next = new Set(checkedKeys);
+	const shouldCheck = resolveTreeCheckState(key, next, index, checkStrictly, onlyCheckLeaf) !== "checked";
+	if (checkStrictly && !onlyCheckLeaf) {
+		if (shouldCheck) next.add(key);
+		else next.delete(key);
+		return [...next];
+	}
+	if (onlyCheckLeaf) {
+		const entry = index.get(key);
+		if (!entry || entry.childrenKeys.length > 0) return [...checkedKeys];
+		if (shouldCheck) next.add(key);
+		else next.delete(key);
+		return [...next];
+	}
+	for (const id of [key, ...collectDescendantKeys(key, index)]) if (shouldCheck) next.add(id);
+	else next.delete(id);
+	let parentKey = index.get(key)?.parentKey ?? null;
+	while (parentKey) {
+		const parent = index.get(parentKey);
+		if (!parent) break;
+		if (parent.childrenKeys.every((childKey) => resolveTreeCheckState(childKey, next, index, false, onlyCheckLeaf) === "checked")) next.add(parentKey);
+		else next.delete(parentKey);
+		parentKey = parent.parentKey;
+	}
+	return [...next];
+}
+function resolveAccordionExpandedKeys(key, expandedKeys, index, rootKeys) {
+	const parentKey = index.get(key)?.parentKey ?? null;
+	const siblings = parentKey ? index.get(parentKey)?.childrenKeys ?? [] : [...rootKeys];
+	const next = new Set(expandedKeys);
+	for (const sibling of siblings) if (sibling !== key) next.delete(sibling);
+	next.add(key);
+	return [...next];
+}
+function resolveTreeFocusKey(flatNodes, currentKey, move, index) {
+	const keys = flatNodes.map((item) => item.key);
+	if (keys.length === 0) return null;
+	if (!currentKey) return keys[0] ?? null;
+	const currentIndex = keys.indexOf(currentKey);
+	if (currentIndex < 0) return keys[0] ?? null;
+	switch (move) {
+		case "next": return keys[Math.min(currentIndex + 1, keys.length - 1)] ?? null;
+		case "prev": return keys[Math.max(currentIndex - 1, 0)] ?? null;
+		case "first": return keys[0] ?? null;
+		case "last": return keys[keys.length - 1] ?? null;
+		case "parent": return index.get(currentKey)?.parentKey ?? currentKey;
+		default: return currentKey;
+	}
+}
+function resolveTreeVirtualEnabled(options) {
+	if (options.virtual) return true;
+	return options.flatCount > (options.virtualThreshold ?? 100);
+}
+function sliceVirtualTreeNodes(nodes, scrollTop, viewportHeight, itemHeight, overscan = 4) {
+	if (nodes.length === 0) return {
+		nodes: [],
+		startIndex: 0,
+		paddingTop: 0,
+		paddingBottom: 0
+	};
+	const totalHeight = nodes.length * itemHeight;
+	const maxScrollTop = Math.max(0, totalHeight - Math.max(0, viewportHeight));
+	const start = Math.max(0, Math.floor(Math.min(Math.max(0, scrollTop), maxScrollTop) / itemHeight) - overscan);
+	const visibleCount = Math.ceil(Math.max(0, viewportHeight) / itemHeight) + overscan * 2;
+	const end = Math.min(nodes.length, start + visibleCount);
+	return {
+		nodes: nodes.slice(start, end),
+		startIndex: start,
+		paddingTop: start * itemHeight,
+		paddingBottom: Math.max(0, totalHeight - end * itemHeight)
+	};
+}
+//#endregion
+export { DEFAULT_TREE_FIELD_NAMES, TREE_INDENT_BY_SIZE, TREE_ROW_HEIGHT, buildTreeNodeIndex, collectDescendantKeys, collectExpandableKeys, collectHalfCheckedKeys, defaultTreeFilterNode, filterTreeNodes, flattenTreeNodeIds, flattenVisibleTreeNodes, getTreeChildren, getTreeIsLeaf, getTreeKey, getTreeLabel, hasTreeChildren, isTreeAncestorKey, isTreeCheckboxDisabled, isTreeNodeDisabled, isTreeNodeLoading, resolveAccordionExpandedKeys, resolveTreeCheckState, resolveTreeFieldNames, resolveTreeFocusKey, resolveTreeIndent, resolveTreeRowHeight, resolveTreeVirtualEnabled, shouldShowTreeCheckbox, sliceVirtualTreeNodes, splitTreeLabelHighlight, toggleTreeCheck };

package/dist/components/tree-select/index.d.ts

@@ -0,0 +1 @@
+export { default as RsTreeSelect } from './src/RsTreeSelect.js';

package/dist/components/tree-select/src/RsTreeSelect.css

@@ -0,0 +1,60 @@
+
+.rs-tree-select[data-v-47b84d55] {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--rs-space-sm);
+  box-sizing: border-box;
+  width: 100%;
+  min-width: 12rem;
+  height: var(--rs-control-height-md);
+  padding: 0 var(--rs-space-md);
+  border: 1px solid var(--rs-input-border, var(--rs-border));
+  border-radius: var(--rs-radius-sm);
+  background: var(--rs-input-bg);
+  color: var(--rs-text);
+  font-size: var(--rs-font-size-sm);
+  cursor: pointer;
+}
+.rs-tree-select--sm[data-v-47b84d55] {
+  height: var(--rs-control-height-sm);
+}
+.rs-tree-select--lg[data-v-47b84d55] {
+  height: var(--rs-control-height-lg);
+}
+.rs-tree-select--disabled[data-v-47b84d55] {
+  opacity: 0.38;
+  cursor: not-allowed;
+}
+.rs-tree-select__placeholder[data-v-47b84d55] {
+  flex: 1;
+  color: var(--rs-muted);
+  text-align: start;
+}
+.rs-tree-select__value[data-v-47b84d55] {
+  flex: 1;
+  overflow: hidden;
+  text-align: start;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.rs-tree-select__clear[data-v-47b84d55] {
+  border: 0;
+  background: transparent;
+  color: var(--rs-muted);
+  cursor: pointer;
+}
+.rs-tree-select__panel[data-v-47b84d55] {
+  max-height: 18rem;
+  padding: var(--rs-space-xs);
+  overflow: auto;
+}
+.rs-tree-select__search[data-v-47b84d55] {
+  box-sizing: border-box;
+  width: 100%;
+  margin-bottom: var(--rs-space-xs);
+  padding: var(--rs-space-xs) var(--rs-space-sm);
+  border: 1px solid var(--rs-input-border, var(--rs-border));
+  border-radius: var(--rs-radius-xs);
+  background: var(--rs-input-bg);
+  color: var(--rs-text);
+}

package/dist/components/tree-select/src/RsTreeSelect.d.ts

@@ -0,0 +1,33 @@
+import type { RsComponentSize } from '../../../theme/types';
+import { type RsTreeFieldNames, type RsTreeNode } from '../../tree/src/tree-utils';
+type __VLS_Props = {
+    treeData: RsTreeNode[];
+    fieldNames?: RsTreeFieldNames;
+    placeholder?: string;
+    disabled?: boolean;
+    allowClear?: boolean;
+    multiple?: boolean;
+    checkable?: boolean;
+    searchable?: boolean;
+    size?: RsComponentSize;
+};
+type __VLS_ModelProps = {
+    modelValue?: string | string[];
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | string[]) => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    multiple: boolean;
+    searchable: boolean;
+    allowClear: boolean;
+    checkable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/tree-select/src/RsTreeSelect.impl.js

@@ -0,0 +1,145 @@
+import { useRsI18n } from "../../../composables/useRsI18n.js";
+import RsIcon_default from "../../icon/src/RsIcon.js";
+import { useResolvedRsComponentSize } from "../../_shared/src/resolve-size.js";
+import RsPopover_default from "../../popover/src/RsPopover.js";
+import { buildTreeNodeIndex, getTreeLabel, resolveTreeFieldNames } from "../../tree/src/tree-utils.js";
+import RsTree_default from "../../tree/src/RsTree.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeModels, normalizeClass, openBlock, ref, toDisplayString, unref, useModel, vModelText, withCtx, withDirectives, withModifiers } from "vue";
+//#region src/components/tree-select/src/RsTreeSelect.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["disabled"];
+var _hoisted_2 = {
+	key: 0,
+	class: "rs-tree-select__value"
+};
+var _hoisted_3 = {
+	key: 1,
+	class: "rs-tree-select__placeholder"
+};
+var _hoisted_4 = ["aria-label"];
+var _hoisted_5 = ["placeholder"];
+var RsTreeSelect_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RsTreeSelect",
+	__name: "RsTreeSelect",
+	props: /*@__PURE__*/ mergeModels({
+		treeData: {},
+		fieldNames: {},
+		placeholder: {},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		allowClear: {
+			type: Boolean,
+			default: false
+		},
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+		checkable: {
+			type: Boolean,
+			default: false
+		},
+		searchable: {
+			type: Boolean,
+			default: false
+		},
+		size: {}
+	}, {
+		"modelValue": { default: "" },
+		"modelModifiers": {},
+		"open": {
+			type: Boolean,
+			default: false
+		},
+		"openModifiers": {}
+	}),
+	emits: ["update:modelValue", "update:open"],
+	setup(__props) {
+		const model = useModel(__props, "modelValue");
+		const open = useModel(__props, "open");
+		const props = __props;
+		const { t } = useRsI18n();
+		const resolvedSize = useResolvedRsComponentSize(() => props.size);
+		const filter = ref("");
+		const names = computed(() => resolveTreeFieldNames(props.fieldNames));
+		const index = computed(() => buildTreeNodeIndex(props.treeData, names.value));
+		const selectedKeys = computed(() => {
+			if (Array.isArray(model.value)) return model.value.map(String);
+			return model.value === "" || model.value == null ? [] : [String(model.value)];
+		});
+		const display = computed(() => {
+			return selectedKeys.value.map((key) => {
+				const entry = index.value.get(key);
+				return entry ? getTreeLabel(entry.node, names.value) : key;
+			}).join(", ");
+		});
+		function onTreeUpdate(value) {
+			model.value = props.multiple || props.checkable ? value : value;
+			if (!props.multiple && !props.checkable) open.value = false;
+		}
+		function onClear() {
+			model.value = props.multiple || props.checkable ? [] : "";
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(RsPopover_default, {
+				open: open.value,
+				"onUpdate:open": _cache[2] || (_cache[2] = ($event) => open.value = $event),
+				side: "bottom",
+				align: "start",
+				width: "md"
+			}, {
+				content: withCtx(() => [createElementVNode("div", {
+					class: "rs-tree-select__panel",
+					onMousedown: _cache[1] || (_cache[1] = withModifiers(() => {}, ["prevent"]))
+				}, [__props.searchable ? withDirectives((openBlock(), createElementBlock("input", {
+					key: 0,
+					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => filter.value = $event),
+					class: "rs-tree-select__search",
+					placeholder: unref(t)("select.searchPlaceholder")
+				}, null, 8, _hoisted_5)), [[vModelText, filter.value]]) : createCommentVNode("", true), createVNode(RsTree_default, {
+					"model-value": __props.multiple || __props.checkable ? selectedKeys.value : selectedKeys.value[0] ?? "",
+					nodes: __props.treeData,
+					"field-names": __props.fieldNames,
+					multiple: __props.multiple,
+					checkable: __props.checkable,
+					filter: filter.value,
+					highlight: "",
+					"default-expand-all": "",
+					"onUpdate:modelValue": onTreeUpdate
+				}, null, 8, [
+					"model-value",
+					"nodes",
+					"field-names",
+					"multiple",
+					"checkable",
+					"filter"
+				])], 32)]),
+				default: withCtx(() => [createElementVNode("button", {
+					type: "button",
+					class: normalizeClass(["rs-tree-select", [`rs-tree-select--${unref(resolvedSize)}`, { "rs-tree-select--disabled": __props.disabled }]]),
+					disabled: __props.disabled
+				}, [
+					display.value ? (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(display.value), 1)) : (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(__props.placeholder ?? unref(t)("select.placeholder")), 1)),
+					__props.allowClear && display.value && !__props.disabled ? (openBlock(), createElementBlock("button", {
+						key: 2,
+						type: "button",
+						class: "rs-tree-select__clear",
+						"aria-label": unref(t)("select.clear"),
+						onClick: withModifiers(onClear, ["stop"])
+					}, [createVNode(RsIcon_default, {
+						name: "x",
+						size: 12
+					})], 8, _hoisted_4)) : createCommentVNode("", true),
+					createVNode(RsIcon_default, {
+						name: "chevron-down",
+						size: 14
+					})
+				], 10, _hoisted_1)]),
+				_: 1
+			}, 8, ["open"]);
+		};
+	}
+});
+//#endregion
+export { RsTreeSelect_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/tree-select/src/RsTreeSelect.js

@@ -0,0 +1,8 @@
+import './RsTreeSelect.css'
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.js";
+import RsTreeSelect_vue_vue_type_script_setup_true_lang_default from "./RsTreeSelect.impl.js";
+
+//#region src/components/tree-select/src/RsTreeSelect.vue
+var RsTreeSelect_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsTreeSelect_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-47b84d55"]]);
+//#endregion
+export { RsTreeSelect_default as default };