@manohub/ui 0.7.1 → 0.8.1

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

@@ -0,0 +1,106 @@
+/**
+ * SelectPanel —— 选择器族的**面板壳内件**（`Select` 与 `SelectTree` 共用，不对外导出）。
+ *
+ * 它只拥有三样东西：**原生 popover 元素**（开合 / Esc / 点外部关闭 / 顶层渲染 / 定位全归浏览器）、
+ * **搜索行**（面板顶部那一个输入框）、以及**内容槽**（列表体或树体）。
+ * 「面板里装什么」不在本件 —— 这正是让列表与树共用同一份面板皮肤的原因。
+ *
+ * 组合类名与服务端三条属性都是**操作层的组合**，不是本件新造的浮层：
+ * `class="mh-popup mh-select__panel mh-popup--anchored"`（状态根 + 本族皮肤 + 显式锚档）、
+ * `data-side` / `data-align`（`popup.css` 的定位档）、`popover="auto"`（原生轻 dismiss）。
+ * 面板宽度跟触发器走：`select.css` 的 `.mh-select__panel` 用 `anchor-size(width)` 取锚点宽，
+ * 锚是挂在**表壳**上的 `.mh-popup-anchor`（触发器进壳后隐式锚会缩成壳内控件，故走显式锚档）。
+ *
+ * `elementRef` 是**由消费方持有的 ref**（不是本件自己的）：开面板（触发器 ↑↓）、收起面板（选中后）、
+ * 以及列表形态的 `.mh-select__option` 焦点遍历都要在父层拿到这个 DOM 元素。
+ */
+import { type PropType, type SlotsType, type VNodeChild } from 'vue';
+import type { ElementRef } from './select-shared';
+export declare const SelectPanel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** 面板 id（必须与触发器的 `popovertarget` 成对） */
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** 面板元素的 ref，由消费方持有（父层要用它开合与遍历选项） */
+    elementRef: {
+        type: PropType<ElementRef>;
+        default: undefined;
+    };
+    /** 是否渲染搜索行（列表形态：`searchable` 或选项多于 8 条；树形态同口径） */
+    searchable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyword: {
+        type: StringConstructor;
+        default: string;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 搜索词变化（消费方负责写回 keyword，并自行决定要不要上抛 `onSearch`） */
+    onKeyword: {
+        type: PropType<(keyword: string) => void>;
+        default: undefined;
+    };
+    /**
+     * 面板上的键盘契约。
+     *
+     * 列表形态给 `↑↓` 移动高亮行（选项是真实 `<button>`，焦点即高亮）；树形态不给 ——
+     * 树的行是 `div`、没有 tabindex，焦点无处可落（与 `Tree` 自身不做键盘导航同口径）。
+     */
+    onKeydown: {
+        type: PropType<(event: KeyboardEvent) => void>;
+        default: undefined;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** 面板 id（必须与触发器的 `popovertarget` 成对） */
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** 面板元素的 ref，由消费方持有（父层要用它开合与遍历选项） */
+    elementRef: {
+        type: PropType<ElementRef>;
+        default: undefined;
+    };
+    /** 是否渲染搜索行（列表形态：`searchable` 或选项多于 8 条；树形态同口径） */
+    searchable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyword: {
+        type: StringConstructor;
+        default: string;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 搜索词变化（消费方负责写回 keyword，并自行决定要不要上抛 `onSearch`） */
+    onKeyword: {
+        type: PropType<(keyword: string) => void>;
+        default: undefined;
+    };
+    /**
+     * 面板上的键盘契约。
+     *
+     * 列表形态给 `↑↓` 移动高亮行（选项是真实 `<button>`，焦点即高亮）；树形态不给 ——
+     * 树的行是 `div`、没有 tabindex，焦点无处可落（与 `Tree` 自身不做键盘导航同口径）。
+     */
+    onKeydown: {
+        type: PropType<(event: KeyboardEvent) => void>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    onKeydown: (event: KeyboardEvent) => void;
+    keyword: string;
+    elementRef: ElementRef;
+    searchable: boolean;
+    searchPlaceholder: string;
+    onKeyword: (keyword: string) => void;
+}, SlotsType<{
+    default?: () => VNodeChild;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,72 @@
+import { defineComponent, createVNode, mergeProps } from "vue";
+const SelectPanel = /* @__PURE__ */ defineComponent({
+  name: "SelectPanel",
+  inheritAttrs: false,
+  props: {
+    /** 面板 id（必须与触发器的 `popovertarget` 成对） */
+    id: {
+      type: String,
+      required: true
+    },
+    /** 面板元素的 ref，由消费方持有（父层要用它开合与遍历选项） */
+    elementRef: {
+      type: Object,
+      default: void 0
+    },
+    /** 是否渲染搜索行（列表形态：`searchable` 或选项多于 8 条；树形态同口径） */
+    searchable: {
+      type: Boolean,
+      default: false
+    },
+    keyword: {
+      type: String,
+      default: ""
+    },
+    searchPlaceholder: {
+      type: String,
+      default: "搜索"
+    },
+    /** 搜索词变化（消费方负责写回 keyword，并自行决定要不要上抛 `onSearch`） */
+    onKeyword: {
+      type: Function,
+      default: void 0
+    },
+    /**
+     * 面板上的键盘契约。
+     *
+     * 列表形态给 `↑↓` 移动高亮行（选项是真实 `<button>`，焦点即高亮）；树形态不给 ——
+     * 树的行是 `div`、没有 tabindex，焦点无处可落（与 `Tree` 自身不做键盘导航同口径）。
+     */
+    onKeydown: {
+      type: Function,
+      default: void 0
+    }
+  },
+  slots: Object,
+  setup(props, {
+    slots
+  }) {
+    return () => createVNode("div", mergeProps({
+      "ref": props.elementRef,
+      "id": props.id
+    }, {
+      popover: "auto"
+    }, {
+      "class": "mh-popup mh-select__panel mh-popup--anchored",
+      "data-side": "bottom",
+      "data-align": "start",
+      "role": "listbox",
+      "onKeydown": props.onKeydown
+    }), [props.searchable ? createVNode("div", {
+      "class": "mh-select__search"
+    }, [createVNode("input", {
+      "class": "mh-input",
+      "value": props.keyword,
+      "placeholder": props.searchPlaceholder,
+      "onInput": (event) => props.onKeyword?.(event.target.value)
+    }, null)]) : null, slots.default?.()]);
+  }
+});
+export {
+  SelectPanel
+};

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

@@ -0,0 +1,64 @@
+/**
+ * 选择器族的**共用原子**（类型、面板 id、popover 开合、触发器键盘契约）。
+ *
+ * 这是 `select/` 目录里的**叶子模块**：它不 import 同目录任何其它文件，因此触发器 / 面板壳 /
+ * 列表体 / 树体四件可以自由地互相组合而不产生环。内件一律**不对外导出**（`src/index.ts` 只出
+ * `Select` 与 `SelectTree`），故本文件的导出面是「族内契约」，改它要同时看那四件。
+ *
+ * 为什么单独一份而不是各自写一遍：这四样都是**跨两件以上**的东西 ——
+ * 类型（列表体与树体都要）、面板 id 生成器（两件的面板都得全页唯一）、
+ * popover 开合（两件都要收起面板）、触发器键盘契约（两件的触发器是同一个形态）。
+ */
+import type { Ref } from 'vue';
+/** 选项（平铺项与分组内选项同构） */
+export interface SelectOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+    /** 分组标题用的标记（内部判别用，消费方不必写） */
+    options?: never;
+}
+/** 分组选项（`{ label: '进行中', options: [...] }`，组内选项与平铺选项同构） */
+export interface SelectOptionGroup {
+    label: string;
+    options: SelectOption[];
+}
+export type SelectItem = SelectOption | SelectOptionGroup;
+export type SelectValue = string | number | Array<string | number>;
+/** 判别：带 `options` 数组的是分组 */
+export declare const isGroup: (item: SelectItem) => item is SelectOptionGroup;
+/** 生成全页唯一的面板 id（随机段与全库其它随机 id 同法） */
+export declare const createSelectPanelId: () => string;
+/**
+ * 开 / 收面板 —— 调的是**原生** `showPopover()` / `hidePopover()`，不是自建浮层逻辑
+ * （面板的开合、Esc、点外部关闭、顶层渲染全归浏览器与 `styles/operations/popup.css`）。
+ *
+ * 先探存在性再调用：jsdom 至今没实现这套 API，直接 `?.()` 会在测试里抛「不是函数」。
+ */
+export declare const showPanel: (element: HTMLElement | null) => void;
+export declare const hidePanel: (element: HTMLElement | null) => void;
+/** 触发器键盘契约的输入 */
+export interface TriggerKeydownOptions {
+    /** 有清除位时才接 `Delete` 清值（与输入框的键盘清除同款） */
+    clearable: boolean;
+    disabled: boolean;
+    clear: () => void;
+    openPanel: () => void;
+    /**
+     * 面板打开后把焦点落到某一项上（**可选**）。
+     *
+     * 列表形态给上它（选项是真实 `<button>`，焦点即高亮）；树形态不给 ——
+     * 树的行是 `div`、没有 tabindex，焦点无处可落。
+     */
+    focusFirst?: (direction: 1 | -1) => void;
+}
+/**
+ * 触发器上的键盘契约（`Select` 与 `SelectTree` 共用一份）。
+ *
+ * `Delete` 清值、`↑` / `↓` 开面板（并可选聚焦首 / 末项）—— 这一对是**触发器形态**的通用操作，
+ * 与「面板里装的是列表还是树」无关，故两件同源。`focusFirst` 的入参是**方向**而不是下标：
+ * 列表侧据此在「尚未聚焦任何项」时落到首项（向下）或末项（向上）。
+ */
+export declare function createTriggerKeydown(options: TriggerKeydownOptions): (event: KeyboardEvent) => void;
+/** 供内件声明 ref 属性用的类型别名（面板壳的 elementRef 入参） */
+export type ElementRef = Ref<HTMLElement | null>;

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

@@ -0,0 +1,24 @@
+const isGroup = (item) => Array.isArray(item.options);
+const PANEL_ID_PREFIX = "mh-select-";
+const createSelectPanelId = () => `${PANEL_ID_PREFIX}${Math.random().toString(36).slice(2, 10)}`;
+const showPanel = (element) => element?.showPopover?.();
+const hidePanel = (element) => element?.hidePopover?.();
+function createTriggerKeydown(options) {
+  return (event) => {
+    if (event.key === "Delete" && options.clearable) options.clear();
+    if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      if (options.disabled) return;
+      options.openPanel();
+      const direction = event.key === "ArrowDown" ? 1 : -1;
+      if (options.focusFirst) requestAnimationFrame(() => options.focusFirst?.(direction));
+    }
+  };
+}
+export {
+  createSelectPanelId,
+  createTriggerKeydown,
+  hidePanel,
+  isGroup,
+  showPanel
+};

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>;