@manohub/ui 0.7.1 → 0.8.0

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

@@ -0,0 +1,61 @@
+/**
+ * 选择器族 · 树形态的**纯函数层**（过滤、命中切分、按值找节点）。
+ *
+ * 为什么单独一层：这三件事都是**数据变换**，与渲染无关，却最容易写错（祖先链要不要留、
+ * 父命中要不要连整支、多次命中怎么切）。抽成不依赖 DOM 的函数后可以直接单测 ——
+ * 用例是 `__tests__/select-tree-filter.spec.ts`，不必挂组件、也不必造 DOM。
+ *
+ * 本文件不 import 任何 Vue 运行时代码（只有类型），也不产出类名 ——
+ * 它是 `select/` 目录里的叶子模块之一。
+ */
+import type { TreeNode } from '../tree';
+/** 树的三条取值口径（与 `Tree` 的同名 prop 同义，故整包传同一个对象即可） */
+export interface TreeAccessors {
+    /** 节点主键：字段名或取值函数 */
+    rowKey: string | ((node: TreeNode) => string);
+    /** 子节点字段名 */
+    childrenKey: string;
+    /** 标签字段名 */
+    labelKey: string;
+}
+/** 取节点主键（与 `Tree` 内部的 `String()` 口径一致：值一律以字符串参与比较） */
+export declare const treeNodeKey: (node: TreeNode, rowKey: TreeAccessors["rowKey"]) => string;
+/** 取子节点（字段不是数组一律当没有子节点，与 `Tree` 同款宽容） */
+export declare const treeChildren: (node: TreeNode, childrenKey: string) => TreeNode[];
+/** 取标签文本 */
+export declare const treeLabel: (node: TreeNode, labelKey: string) => string;
+/** 按主键在整棵树里找节点（触发器要显示选中节点的名称；找不到时由消费方回退显示原值） */
+export declare function findTreeNode(nodes: TreeNode[], key: string, accessors: Pick<TreeAccessors, 'rowKey' | 'childrenKey'>): TreeNode | undefined;
+export interface TreeFilterOptions extends TreeAccessors {
+    /** 关键词（调用方保证非空；空串走「不过滤」那条路，不进本函数） */
+    keyword: string;
+    /** 自定义命中判定（缺省：标签**区分大小写**地包含关键词 —— 与 `Select` 的缺省过滤同口径） */
+    match?: (node: TreeNode, keyword: string) => boolean;
+}
+export interface TreeFilterResult {
+    /** 过滤后的树（命中项 + 它们的祖先链；被剪掉的分支不在其中） */
+    nodes: TreeNode[];
+    /** 结果里出现的**全部**节点 key（含祖先）—— 消费方用它做「过滤态强制全展」 */
+    keys: string[];
+}
+/**
+ * 过滤树。三条规则（**父命中即整支可见**，与「搜到的域要连带其下所有条目」的直觉一致）：
+ *
+ * 1. 节点**自身命中** → 保留它**及其整棵子树**（子树原引用，不改数据）；
+ * 2. 自身未命中但**后代有命中** → 保留该节点 + 递归过滤后的子树（即**保留祖先链**）；
+ * 3. 整支无命中 → 剪掉。
+ *
+ * 复杂度 O(N)（每个节点只看一次），只在关键词或数据变化时由 `computed` 触发。
+ */
+export declare function filterTreeNodes(nodes: TreeNode[], options: TreeFilterOptions): TreeFilterResult;
+/** 命中切分的一段：`hit` 为真时由面层给底色（`.mh-select__hit`） */
+export interface HitSegment {
+    text: string;
+    hit: boolean;
+}
+/**
+ * 把标签文本按关键词切成「命中 / 未命中」交替的片段（**全部**出现位置都切，不只第一处）。
+ *
+ * 关键词为空、或压根没命中时返回**一整段未命中**（消费方据此仍能渲染出原文，不必分情况）。
+ */
+export declare function splitHighlight(text: string, keyword: string): HitSegment[];

package/dist/components/select/select-tree-filter.js

@@ -0,0 +1,63 @@
+const treeNodeKey = (node, rowKey) => typeof rowKey === "function" ? rowKey(node) : String(node[rowKey] ?? "");
+const treeChildren = (node, childrenKey) => {
+  const children = node[childrenKey];
+  return Array.isArray(children) ? children : [];
+};
+const treeLabel = (node, labelKey) => String(node[labelKey] ?? "");
+function findTreeNode(nodes, key, accessors) {
+  for (const node of nodes) {
+    if (treeNodeKey(node, accessors.rowKey) === key) return node;
+    const found = findTreeNode(treeChildren(node, accessors.childrenKey), key, accessors);
+    if (found) return found;
+  }
+  return void 0;
+}
+function filterTreeNodes(nodes, options) {
+  const hit = (node) => options.match ? options.match(node, options.keyword) : treeLabel(node, options.labelKey).includes(options.keyword);
+  const keys = [];
+  const collectKeys = (node) => {
+    keys.push(treeNodeKey(node, options.rowKey));
+    for (const child of treeChildren(node, options.childrenKey)) collectKeys(child);
+  };
+  const walk = (list) => {
+    const kept = [];
+    for (const node of list) {
+      if (hit(node)) {
+        collectKeys(node);
+        kept.push(node);
+        continue;
+      }
+      keys.push(treeNodeKey(node, options.rowKey));
+      const keptChildren = walk(treeChildren(node, options.childrenKey));
+      if (keptChildren.length) {
+        kept.push({ ...node, [options.childrenKey]: keptChildren });
+      } else {
+        keys.pop();
+      }
+    }
+    return kept;
+  };
+  return { nodes: walk(nodes), keys };
+}
+function splitHighlight(text, keyword) {
+  if (!keyword) return [{ text, hit: false }];
+  const segments = [];
+  let cursor = 0;
+  for (; ; ) {
+    const at = text.indexOf(keyword, cursor);
+    if (at < 0) break;
+    if (at > cursor) segments.push({ text: text.slice(cursor, at), hit: false });
+    segments.push({ text: text.slice(at, at + keyword.length), hit: true });
+    cursor = at + keyword.length;
+  }
+  if (cursor < text.length) segments.push({ text: text.slice(cursor), hit: false });
+  return segments.length ? segments : [{ text, hit: false }];
+}
+export {
+  filterTreeNodes,
+  findTreeNode,
+  splitHighlight,
+  treeChildren,
+  treeLabel,
+  treeNodeKey
+};

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

@@ -0,0 +1,274 @@
+/**
+ * SelectTree —— **树选择**（`Select` 的树形态，与它平级导出：`import { SelectTree } from '@manohub/ui'`）。
+ *
+ * 它与 `Select` 共用**同一批内件**：触发器（像输入框 / 清除位 / 箭头 / 键盘开面板）、
+ * 面板壳（皮肤 / 定位档 / 显式锚 / 搜索行）、共用原子（面板 id / popover 开合 / 键盘契约）。
+ * 所以「面板长相与开合行为」两件只有一份规格；本件独有的只有**树体那一层**：
+ *
+ * 1. **仅叶子可选**：点叶子行即选中并收起面板；点父节点行只切换展开（不产生选中值）——
+ *    父节点是「分组」而不是「选项」，选中它语义上是空的（`Tree` 自身不做这个判断，故在此兜住）。
+ * 2. **本地过滤树**：搜索行在场时按关键词过滤，命中节点的**祖先链保留**、父节点自身命中则
+ *    **整支保留**，并强制全展到命中层（算法与切分都是纯函数，见 `select-tree-filter.ts`）；
+ *    命中文本按面层的 `.mh-select__hit` 高亮（靠 `Tree` 的可选 `renderLabel` 钩子落进标签槽）。
+ * 3. **面板内限高滚动**：树体包在 `.mh-select__tree` 里（内距 + 限高 + 溢出滚动），长树不撑破面板。
+ *
+ * ## 与 `Select` 的三处有意差异（都是「树不是列表」决定的）
+ *
+ * | 事项 | `Select` | `SelectTree` |
+ * | --- | --- | --- |
+ * | 值 | `string \| number \| Array<…>` | 只单选、只 `string`（`Tree` 的主键本就 `String()` 化） |
+ * | 面板内 ↑↓ 行导航 | 有（选项是真实 `<button>`，焦点即高亮） | **无**（树的行是 `div`、没有 tabindex；`Tree` 自身也不做键盘导航） |
+ * | 空 / 加载态 | 列表体的内建行 | 面板内同样出一行文字（**不复用**整件三态容器：下拉里出空态插画太重） |
+ *
+ * @example 基础单选
+ * <SelectTree nodes={tree} rowKey="id" modelValue={v} onChange={setV} placeholder="请选择业务域" />
+ *
+ * @example 搜索 + 默认全展开
+ * <SelectTree nodes={tree} rowKey="id" labelKey="name" searchable defaultExpandAll onChange={setV} />
+ */
+import { type PropType, type SlotsType, type VNodeChild } from 'vue';
+import type { ControlSize } from '../control-size';
+import type { InputStatus } from '../input';
+import { type TreeNode } from '../tree';
+export declare const SelectTree: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** 树数据（与 `Tree` 同一个 `TreeNode` 类型，不另造节点形状） */
+    nodes: {
+        type: PropType<TreeNode[]>;
+        required: true;
+    };
+    /** 节点主键：字段名或取值函数（与 `Tree` 同义） */
+    rowKey: {
+        type: PropType<string | ((node: TreeNode) => string)>;
+        required: true;
+    };
+    /** 标签字段名（默认 'label'） */
+    labelKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 子节点字段名（默认 'children'） */
+    childrenKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 受控值（选中叶子的主键；树选择只单选） */
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** 非受控初始值 */
+    defaultValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 搜索：`true` 强制开；不给时节点总数多于 8 自动开（与 `Select` 同口径） */
+    searchable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 自定义命中判定（缺省：标签区分大小写地包含关键词） */
+    filterNode: {
+        type: PropType<(node: TreeNode, keyword: string) => boolean>;
+        default: undefined;
+    };
+    /** 命中文本是否高亮（默认开） */
+    highlight: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 受控展开集（传了就完全受控；**过滤态下组件强制全展**，不受本 prop 约束） */
+    expandedKeys: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    /** 非受控展开初值 */
+    defaultExpandedKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    /** 初始展开全部（与 `defaultExpandedKeys` 互斥，它优先） */
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 展开集变化回调 */
+    onExpandChange: {
+        type: PropType<(keys: string[]) => void>;
+        default: undefined;
+    };
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 加载中（面板里出一行提示，不渲染树） */
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyText: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 尺寸档（24 / 28 / 32） */
+    size: {
+        type: PropType<ControlSize>;
+        default: string;
+    };
+    /** 校验状态（红 / 黄；与 `Input` 同一词表） */
+    status: {
+        type: PropType<InputStatus>;
+        default: undefined;
+    };
+    /** 值变更回调（选中叶子的主键） */
+    onChange: {
+        type: PropType<(v: string) => void>;
+        default: undefined;
+    };
+    /** 搜索词变更（远程换数据用；本地过滤不受它影响） */
+    onSearch: {
+        type: PropType<(keyword: string) => void>;
+        default: undefined;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:modelValue': (v: string) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** 树数据（与 `Tree` 同一个 `TreeNode` 类型，不另造节点形状） */
+    nodes: {
+        type: PropType<TreeNode[]>;
+        required: true;
+    };
+    /** 节点主键：字段名或取值函数（与 `Tree` 同义） */
+    rowKey: {
+        type: PropType<string | ((node: TreeNode) => string)>;
+        required: true;
+    };
+    /** 标签字段名（默认 'label'） */
+    labelKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 子节点字段名（默认 'children'） */
+    childrenKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 受控值（选中叶子的主键；树选择只单选） */
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** 非受控初始值 */
+    defaultValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 搜索：`true` 强制开；不给时节点总数多于 8 自动开（与 `Select` 同口径） */
+    searchable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 自定义命中判定（缺省：标签区分大小写地包含关键词） */
+    filterNode: {
+        type: PropType<(node: TreeNode, keyword: string) => boolean>;
+        default: undefined;
+    };
+    /** 命中文本是否高亮（默认开） */
+    highlight: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 受控展开集（传了就完全受控；**过滤态下组件强制全展**，不受本 prop 约束） */
+    expandedKeys: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    /** 非受控展开初值 */
+    defaultExpandedKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    /** 初始展开全部（与 `defaultExpandedKeys` 互斥，它优先） */
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 展开集变化回调 */
+    onExpandChange: {
+        type: PropType<(keys: string[]) => void>;
+        default: undefined;
+    };
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 加载中（面板里出一行提示，不渲染树） */
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyText: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 尺寸档（24 / 28 / 32） */
+    size: {
+        type: PropType<ControlSize>;
+        default: string;
+    };
+    /** 校验状态（红 / 黄；与 `Input` 同一词表） */
+    status: {
+        type: PropType<InputStatus>;
+        default: undefined;
+    };
+    /** 值变更回调（选中叶子的主键） */
+    onChange: {
+        type: PropType<(v: string) => void>;
+        default: undefined;
+    };
+    /** 搜索词变更（远程换数据用；本地过滤不受它影响） */
+    onSearch: {
+        type: PropType<(keyword: string) => void>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((v: string) => any) | undefined;
+}>, {
+    size: ControlSize;
+    disabled: boolean;
+    onChange: (v: string) => void;
+    loading: boolean;
+    labelKey: string;
+    childrenKey: string;
+    expandedKeys: string[];
+    defaultExpandedKeys: string[];
+    defaultExpandAll: boolean;
+    onExpandChange: (keys: string[]) => void;
+    defaultValue: string;
+    placeholder: string;
+    modelValue: string;
+    status: InputStatus;
+    clearable: boolean;
+    onSearch: (keyword: string) => void;
+    emptyText: string;
+    searchable: boolean;
+    filterNode: (node: TreeNode, keyword: string) => boolean;
+    highlight: boolean;
+}, SlotsType<{
+    empty?: () => VNodeChild;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,263 @@
+import { defineComponent, ref, computed, watch, createVNode, createTextVNode, Fragment } from "vue";
+import { Tree } from "../tree/index.js";
+import { SelectPanel } from "./select-panel.js";
+import { SelectTrigger } from "./select-trigger.js";
+import { createSelectPanelId, createTriggerKeydown, showPanel, hidePanel } from "./select-shared.js";
+import { filterTreeNodes, findTreeNode, treeLabel, splitHighlight, treeChildren, treeNodeKey } from "./select-tree-filter.js";
+const SelectTree = /* @__PURE__ */ defineComponent({
+  name: "SelectTree",
+  inheritAttrs: false,
+  props: {
+    /** 树数据（与 `Tree` 同一个 `TreeNode` 类型，不另造节点形状） */
+    nodes: {
+      type: Array,
+      required: true
+    },
+    /** 节点主键：字段名或取值函数（与 `Tree` 同义） */
+    rowKey: {
+      type: [String, Function],
+      required: true
+    },
+    /** 标签字段名（默认 'label'） */
+    labelKey: {
+      type: String,
+      default: "label"
+    },
+    /** 子节点字段名（默认 'children'） */
+    childrenKey: {
+      type: String,
+      default: "children"
+    },
+    /** 受控值（选中叶子的主键；树选择只单选） */
+    modelValue: {
+      type: String,
+      default: void 0
+    },
+    /** 非受控初始值 */
+    defaultValue: {
+      type: String,
+      default: void 0
+    },
+    placeholder: {
+      type: String,
+      default: "请选择"
+    },
+    /** 搜索：`true` 强制开；不给时节点总数多于 8 自动开（与 `Select` 同口径） */
+    searchable: {
+      type: Boolean,
+      default: false
+    },
+    /** 自定义命中判定（缺省：标签区分大小写地包含关键词） */
+    filterNode: {
+      type: Function,
+      default: void 0
+    },
+    /** 命中文本是否高亮（默认开） */
+    highlight: {
+      type: Boolean,
+      default: true
+    },
+    /** 受控展开集（传了就完全受控；**过滤态下组件强制全展**，不受本 prop 约束） */
+    expandedKeys: {
+      type: Array,
+      default: void 0
+    },
+    /** 非受控展开初值 */
+    defaultExpandedKeys: {
+      type: Array,
+      default: () => []
+    },
+    /** 初始展开全部（与 `defaultExpandedKeys` 互斥，它优先） */
+    defaultExpandAll: {
+      type: Boolean,
+      default: false
+    },
+    /** 展开集变化回调 */
+    onExpandChange: {
+      type: Function,
+      default: void 0
+    },
+    clearable: {
+      type: Boolean,
+      default: false
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    /** 加载中（面板里出一行提示，不渲染树） */
+    loading: {
+      type: Boolean,
+      default: false
+    },
+    emptyText: {
+      type: String,
+      default: "暂无数据"
+    },
+    /** 尺寸档（24 / 28 / 32） */
+    size: {
+      type: String,
+      default: "md"
+    },
+    /** 校验状态（红 / 黄；与 `Input` 同一词表） */
+    status: {
+      type: String,
+      default: void 0
+    },
+    /** 值变更回调（选中叶子的主键） */
+    onChange: {
+      type: Function,
+      default: void 0
+    },
+    /** 搜索词变更（远程换数据用；本地过滤不受它影响） */
+    onSearch: {
+      type: Function,
+      default: void 0
+    }
+  },
+  emits: {
+    "update:modelValue": (v) => true
+  },
+  slots: Object,
+  setup(props, {
+    emit,
+    slots,
+    attrs
+  }) {
+    const panelId = createSelectPanelId();
+    const panelRef = ref(null);
+    const inner = ref(props.defaultValue);
+    const keyword = ref("");
+    const keyOf = (node) => treeNodeKey(node, props.rowKey);
+    const childrenOf = (node) => treeChildren(node, props.childrenKey);
+    const current = computed(() => props.modelValue ?? inner.value);
+    const hasValue = computed(() => current.value !== void 0 && current.value !== "");
+    const nodeCount = computed(() => {
+      let count = 0;
+      const walk = (list) => {
+        for (const node of list) {
+          count += 1;
+          walk(childrenOf(node));
+        }
+      };
+      walk(props.nodes);
+      return count;
+    });
+    const showSearch = computed(() => props.searchable || nodeCount.value > 8);
+    const collectKeys = (list) => list.flatMap((node) => [keyOf(node), ...collectKeys(childrenOf(node))]);
+    const innerExpanded = ref(props.defaultExpandAll ? collectKeys(props.nodes) : [...props.defaultExpandedKeys]);
+    watch(() => props.defaultExpandedKeys, (next) => {
+      if (props.expandedKeys === void 0) innerExpanded.value = [...next];
+    });
+    const filtered = computed(() => keyword.value ? filterTreeNodes(props.nodes, {
+      rowKey: props.rowKey,
+      childrenKey: props.childrenKey,
+      labelKey: props.labelKey,
+      keyword: keyword.value,
+      match: props.filterNode
+    }) : void 0);
+    const visibleNodes = computed(() => filtered.value?.nodes ?? props.nodes);
+    const expandedKeys = computed(() => filtered.value ? filtered.value.keys : props.expandedKeys ?? innerExpanded.value);
+    const handleExpandChange = (keys) => {
+      if (props.expandedKeys === void 0) innerExpanded.value = keys;
+      props.onExpandChange?.(keys);
+    };
+    const displayLabel = computed(() => {
+      if (!hasValue.value) return void 0;
+      const found = findTreeNode(props.nodes, String(current.value), {
+        rowKey: props.rowKey,
+        childrenKey: props.childrenKey
+      });
+      return found ? treeLabel(found, props.labelKey) : String(current.value);
+    });
+    const commit = (value) => {
+      if (props.modelValue === void 0) inner.value = value;
+      emit("update:modelValue", value);
+      props.onChange?.(value);
+    };
+    const hide = () => hidePanel(panelRef.value);
+    const toggleExpand = (key) => {
+      const next = new Set(expandedKeys.value);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      handleExpandChange([...next]);
+    };
+    const pick = (node) => {
+      if (childrenOf(node).length > 0) {
+        toggleExpand(keyOf(node));
+        return;
+      }
+      commit(keyOf(node));
+      hide();
+    };
+    const clear = () => commit("");
+    const onTriggerKeydown = createTriggerKeydown({
+      clearable: props.clearable,
+      disabled: props.disabled,
+      clear,
+      openPanel: () => showPanel(panelRef.value)
+      /* 有意不给 `focusFirst`：树的行是 `div`、没有 tabindex，面板内不做 ↑↓ 行导航 */
+    });
+    const renderHitLabel = (node) => createVNode(Fragment, null, [splitHighlight(treeLabel(node, props.labelKey), keyword.value).map((segment, index) => segment.hit ? createVNode("span", {
+      "key": index,
+      "class": "mh-select__hit"
+    }, [segment.text]) : segment.text)]);
+    return () => {
+      const highlightLabel = props.highlight && !!keyword.value ? renderHitLabel : void 0;
+      return createVNode("div", {
+        "class": ["mh-popup-host", attrs.class].filter(Boolean).join(" "),
+        "style": attrs.style
+      }, [createVNode(SelectTrigger, {
+        "panelId": panelId,
+        "size": props.size,
+        "status": props.status,
+        "disabled": props.disabled,
+        "clearable": props.clearable,
+        "hasValue": hasValue.value,
+        "placeholder": props.placeholder,
+        "label": displayLabel.value,
+        "onKeydown": onTriggerKeydown,
+        "onClear": clear
+      }, null), createVNode(SelectPanel, {
+        "id": panelId,
+        "elementRef": panelRef,
+        "searchable": showSearch.value,
+        "keyword": keyword.value,
+        "onKeyword": (value) => {
+          keyword.value = value;
+          props.onSearch?.(value);
+        }
+      }, {
+        default: () => {
+          if (props.loading) {
+            return createVNode("span", {
+              "class": "mh-select__option mh-select__option--hint"
+            }, [createTextVNode("加载中…")]);
+          }
+          if (visibleNodes.value.length === 0) {
+            const custom = slots.empty?.();
+            return custom !== void 0 && custom !== null ? custom : createVNode("span", {
+              "class": "mh-select__option mh-select__option--empty"
+            }, [props.emptyText]);
+          }
+          return createVNode("div", {
+            "class": "mh-select__tree"
+          }, [createVNode(Tree, {
+            "nodes": visibleNodes.value,
+            "rowKey": props.rowKey,
+            "labelKey": props.labelKey,
+            "childrenKey": props.childrenKey,
+            "selected": current.value === "" ? void 0 : current.value,
+            "expandedKeys": expandedKeys.value,
+            "onExpandChange": handleExpandChange,
+            "onSelect": pick,
+            "renderLabel": highlightLabel
+          }, null)]);
+        }
+      })]);
+    };
+  }
+});
+export {
+  SelectTree
+};