@splicetree/plugin-keyboard 0.0.1 → 0.1.1

package/CHANGELOG.md

@@ -1,25 +1,22 @@
 # @splicetree/plugin-keyboard
 
+## 0.1.1
+
+### Patch Changes
+
+- fix: republish plugin-keyboard after partial release failure
+
+## 0.1.0
+
+### Minor Changes
+
+- ### @splicetree/plugin-keyboard
+  - 只采集方向键并统一派发 `input:direction`
+  - 配置聚合到 `configuration.keyboard`：`autoListen/target/keymap`
+  - 自动为目标容器添加 `tabindex="0"` 并聚焦
+
 ## 0.0.1
 
 ### Patch Changes
 
 - chore: 搭建 SpliceTree 框架基础架构与工程体系
-
-  框架架构：
-  - 建立无头树（Headless Tree）核心模型与数据结构
-  - 定义节点操作 API、事件系统和状态管理机制
-  - 设计并实现插件体系（生命周期、注册机制、能力扩展）
-  - 引入模块化架构，明确 core / plugins / adapters 的边界
-  - 预留扩展点与内部协议，构建可插拔式架构基础
-
-  适配层与生态：
-  - 添加 Vue 3 适配层（渲染无关、纯接口绑定）
-  - 设计独立的 UI 层解耦策略，确保跨框架可迁移
-  - 预留未来 React/Svelte/WebComponents 的适配接口
-
-  工程化与工具链：
-  - 初始化 monorepo 工程结构（packages + docs）
-  - 配置构建工具链 tsdown（多包构建、类型输出）
-  - 构建文档系统（VitePress）与基础导航结构
-  - 设置开发环境、代码规范（ESLint）、格式化流程

package/README.md

@@ -1,13 +1,13 @@
 # @splicetree/plugin-keyboard
 
+提供快捷键导航能力：上下移动、展开与收起。
+
 [![version](https://img.shields.io/npm/v/@splicetree/plugin-keyboard.svg?label=version)](https://www.npmjs.com/package/@splicetree/plugin-keyboard)
 [![downloads](https://img.shields.io/npm/dm/@splicetree/plugin-keyboard.svg)](https://npmcharts.com/compare/%40splicetree%2Fplugin-keyboard?minimal=true)
 [![license](https://img.shields.io/npm/l/@splicetree/plugin-keyboard.svg)](https://www.npmjs.com/package/@splicetree/plugin-keyboard)
 [![Website](https://img.shields.io/static/v1?label=Website&message=splicetree.dev&color=blue)](https://www.splicetree.dev)
 [![GitHub](https://img.shields.io/static/v1?label=GitHub&message=splicetree%2Fsplicetree&logo=github)](https://github.com/michaelcocova/splicetree)
 
-提供快捷键导航能力：上下移动、展开与收起。
-
 ## 安装
 
 `pnpm add @splicetree/plugin-keyboard`
@@ -20,32 +20,28 @@ import keyboardNavigation from '@splicetree/plugin-keyboard'
 
 const tree = createSpliceTree(data, {
   plugins: [keyboardNavigation],
-  defaultActive: 'a',
-  autoListenKeyboard: true,
-  keymap: { expand: 'ArrowRight', collapse: 'ArrowLeft', next: 'ArrowDown', prev: 'ArrowUp' },
+  configuration: {
+    keyboard: {
+      autoListen: true,
+      target: '.keyboard-wrap',
+      keymap: { up: 'ArrowUp', down: 'ArrowDown', left: 'ArrowLeft', right: 'ArrowRight' },
+    },
+  },
 })
 ```
 
 ## Api
 
-### Options
+### Configuration
 
-| 选项                 | 类型                                                                   | 默认值          | 说明                             |
-| -------------------- | ---------------------------------------------------------------------- | --------------- | -------------------------------- |
-| `defaultActive`      | `string`                                                               | `undefined`     | 默认激活节点                     |
-| `autoListenKeyboard` | `boolean`                                                              | `true`          | 是否自动监听键盘事件             |
-| `keymap`             | `{ expand?: string; collapse?: string; next?: string; prev?: string }` | `见下`          | 快捷键映射（默认：左右上下箭头） |
-| `keyboardTarget`     | `HTMLElement`                                                          | `document.body` | 键盘监听目标                     |
+- `configuration.keyboard.autoListen: boolean` 是否自动监听键盘（默认 `true`）
+- `configuration.keyboard.target: HTMLElement | string | (() => HTMLElement | null)` 监听目标
+- `configuration.keyboard.keymap: { up?: string; down?: string; left?: string; right?: string }` 快捷键映射
 
 ### 实例方法
 
-| 名称                    | 参数                       | 说明                   |
-| ----------------------- | -------------------------- | ---------------------- |
-| `activeId`              | `无`                       | 当前激活的节点         |
-| `toggleActive(id, on?)` | `id: string; on?: boolean` | 切换或显式设置激活状态 |
+- `activeId?: string` 当前激活节点 id（与选择插件协同）
 
 ### 节点方法
 
-| 名称                | 参数           | 说明                 |
-| ------------------- | -------------- | -------------------- |
-| `toggleActive(on?)` | `on?: boolean` | 切换或显式设置激活态 |
+- 无（键盘插件不扩展节点方法，专注输入事件）

package/dist/index.d.ts

@@ -1,72 +1,42 @@
 import { SpliceTreePlugin } from "@splicetree/core";
 
 //#region src/index.d.ts
+interface KeyboardKeymap {
+  up?: string;
+  down?: string;
+  left?: string;
+  right?: string;
+}
 type KeyboardTargetType = HTMLElement | string | null | undefined;
 type KeyboardTarget = KeyboardTargetType | (() => KeyboardTargetType);
+interface Modifiers {
+  shift: boolean;
+  ctrl: boolean;
+  meta: boolean;
+  alt: boolean;
+}
 declare module '@splicetree/core' {
-  interface UseSpliceTreeOptions {
-    /**
-     * 默认激活节点 ID
-     * @default undefined
-     */
-    defaultActive?: string;
-    /**
-     * 是否自动监听键盘事件
-     * 开启后，插件会自动监听键盘事件
-     * 关闭后，需要手动调用 `listenKeyboard` 方法监听键盘事件
-     * @default true
-     */
-    autoListenKeyboard?: boolean;
-    /**
-     * 键盘导航快捷键
-     * @default { expand: 'ArrowRight', collapse: 'ArrowLeft', next: 'ArrowDown', prev: 'ArrowUp' }
-     */
-    keymap?: {
-      expand?: string;
-      collapse?: string;
-      next?: string;
-      prev?: string;
+  interface SpliceTreeConfiguration {
+    keyboard?: {
+      autoListen?: boolean;
+      target?: KeyboardTarget;
+      keymap?: KeyboardKeymap;
     };
-    /**
-     * 键盘导航目标元素
-     * @default document.body
-     */
-    keyboardTarget?: KeyboardTarget;
   }
-  /**
-   * 实例扩展（Keyboard）
-   * - activeId：当前激活的节点 id
-   * - toggleActive：切换或显式设置某节点的激活态
-   */
-  interface SpliceTreeInstance {
-    /**
-     * 当前激活的节点 id（未激活时为 undefined）
-     */
-    activeId?: string;
-    /**
-     * 切换或显式设置某节点的激活态
-     * @param id 节点 id
-     * @param active 不传表示切换；true/false 表示显式设置
-     */
-    toggleActive: (id: string, active?: boolean) => void;
+  interface SpliceTreeEventPayloadMap {
+    'input:direction': {
+      direction: 'up' | 'down' | 'left' | 'right';
+      modifiers: Modifiers;
+    };
+    'input:node-click': {
+      nodeId: string;
+      modifiers: Modifiers;
+    };
   }
-  /**
-   * 节点扩展（Keyboard）
-   * - isActive：当前节点是否激活
-   * - toggleActive：切换当前节点的激活态
-   */
-  interface SpliceTreeNode {
-    /**
-     * 当前节点是否为激活态
-     */
-    isActive: () => boolean;
-    /**
-     * 切换当前节点的激活态
-     * @param active 不传表示切换；true/false 表示显式设置
-     */
-    toggleActive: (active?: boolean) => void;
+  interface SpliceTreeInstance {
+    emitNodeClick: (nodeId: string, e: MouseEvent) => void;
   }
 }
-declare const keyboardNavigation: SpliceTreePlugin;
+declare const keyboardPlugin: SpliceTreePlugin;
 //#endregion
-export { keyboardNavigation as default, keyboardNavigation };
+export { keyboardPlugin as default, keyboardPlugin };

package/dist/index.js

@@ -1,147 +1,79 @@
 //#region src/index.ts
-/**
-* 解析键盘监听目标元素
-* 支持传入选择器、元素实例或函数
-*/
-function resolveKeyboardTarget(targe) {
-	if (typeof targe === "string") return document.querySelector(targe);
-	if (targe instanceof HTMLElement) return targe;
-	if (typeof targe === "function") return resolveKeyboardTarget(targe?.());
+function resolveTarget(target) {
+	if (typeof target === "string") return document.querySelector(target);
+	if (target instanceof HTMLElement) return target;
+	if (typeof target === "function") return resolveTarget(target());
 	return null;
 }
-const keyboardNavigation = {
+function getModifiers(e) {
+	return {
+		shift: e.shiftKey,
+		ctrl: e.ctrlKey,
+		meta: e.metaKey,
+		alt: e.altKey
+	};
+}
+const keyboardPlugin = {
 	name: "keyboard",
 	setup(ctx) {
-		const { defaultActive, autoListenKeyboard = true, keyboardTarget, keymap } = ctx.options;
-		let activeId = defaultActive;
-		Object.defineProperty(ctx.tree, "activeId", {
-			get() {
-				return activeId;
-			},
-			configurable: true,
-			enumerable: true
-		});
-		/**
-		* 切换或设置激活节点
-		* 更新后派发 visibility 事件以刷新视图
-		* @param id 节点 id
-		* @param active 不传表示切换；true/false 表示显式设置
-		*/
-		const toggleActive = (id, active) => {
-			if (active === void 0) activeId = activeId === id ? void 0 : id;
-			else if (active) activeId = id;
-			else if (activeId === id) activeId = void 0;
-			ctx.events.emit({
-				name: "visibility",
-				keys: ctx.tree.expandedKeys()
-			});
+		const config = ctx.options?.configuration?.keyboard ?? {};
+		const autoListenKeyboard = config.autoListen ?? true;
+		const keyboardTarget = config.target;
+		const keymap = config.keymap;
+		const keys = {
+			up: keymap?.up ?? "ArrowUp",
+			down: keymap?.down ?? "ArrowDown",
+			left: keymap?.left ?? "ArrowLeft",
+			right: keymap?.right ?? "ArrowRight"
 		};
-		/**
-		* 按可见序列移动激活项
-		* @param delta 移动步长（-1 上一个，1 下一个）
-		*/
-		const moveActive = (delta) => {
-			const items = ctx.tree.items();
-			if (!items.length) return;
-			const idx = activeId ? items.findIndex((n) => n.id === activeId) : -1;
-			activeId = items[Math.max(0, Math.min(items.length - 1, idx < 0 ? 0 : idx + delta))]?.id;
+		const emitDirection = (direction, e) => {
 			ctx.events.emit({
-				name: "visibility",
-				keys: ctx.tree.expandedKeys()
+				name: "input:direction",
+				direction,
+				modifiers: getModifiers(e)
 			});
 		};
-		/**
-		* 激活上一个可见节点
-		*/
-		const keyUp = () => moveActive(-1);
-		/**
-		* 激活下一个可见节点
-		*/
-		const keyDown = () => moveActive(1);
-		/**
-		* 左方向键：优先收起；否则激活父节点
-		*/
-		const keyLeft = () => {
-			if (!activeId) return;
-			const node = ctx.tree.getNode(activeId);
-			if (!node) return;
-			if (ctx.tree.isExpanded(node.id)) ctx.tree.collapse(node.id);
-			else if (node.getParent()?.id) activeId = node.getParent().id;
-			ctx.events.emit({
-				name: "visibility",
-				keys: ctx.tree.expandedKeys()
-			});
-		};
-		/**
-		* 右方向键：优先展开；已展开则进入第一个子节点
-		*/
-		const keyRight = () => {
-			if (!activeId) return;
-			const node = ctx.tree.getNode(activeId);
-			if (!node) return;
-			if (!ctx.tree.isExpanded(node.id)) ctx.tree.expand(node.id);
-			else {
-				const first = node.getChildren()[0];
-				if (first) activeId = first.id;
+		const onKeydown = (e) => {
+			switch (e.key) {
+				case keys.up:
+					e.preventDefault();
+					emitDirection("up", e);
+					break;
+				case keys.down:
+					e.preventDefault();
+					emitDirection("down", e);
+					break;
+				case keys.left:
+					e.preventDefault();
+					emitDirection("left", e);
+					break;
+				case keys.right:
+					e.preventDefault();
+					emitDirection("right", e);
+					break;
 			}
+		};
+		const emitNodeClick = (nodeId, e) => {
 			ctx.events.emit({
-				name: "visibility",
-				keys: ctx.tree.expandedKeys()
+				name: "input:node-click",
+				nodeId,
+				modifiers: getModifiers(e)
 			});
 		};
-		/**
-		* 键盘按下事件处理
-		* - 根据 keymap 映射调用对应处理函数
-		* - 自动阻止默认行为以避免滚动
-		*/
-		const onKeydown = (e) => {
-			const kExpand = keymap?.expand ?? "ArrowRight";
-			const kCollapse = keymap?.collapse ?? "ArrowLeft";
-			const kNext = keymap?.next ?? "ArrowDown";
-			const kPrev = keymap?.prev ?? "ArrowUp";
-			const key = e.key;
-			if (key === kPrev) {
-				e.preventDefault();
-				keyUp();
-				return;
-			}
-			if (key === kNext) {
-				e.preventDefault();
-				keyDown();
-				return;
-			}
-			if (key === kCollapse) {
-				e.preventDefault();
-				keyLeft();
-				return;
-			}
-			if (key === kExpand) {
-				e.preventDefault();
-				keyRight();
-			}
-		};
 		if (autoListenKeyboard && typeof document !== "undefined") setTimeout(() => {
-			const root = resolveKeyboardTarget(keyboardTarget);
-			if (root) {
-				root.setAttribute("tabindex", "0");
-				root?.focus?.();
-			}
+			const root = resolveTarget(keyboardTarget);
+			if (!root) return;
+			root.setAttribute("tabindex", "0");
 			const handler = (e) => {
 				const active = document.activeElement;
-				if (!root || root.contains(active)) onKeydown(e);
+				if (root.contains(active)) onKeydown(e);
 			};
 			document.addEventListener("keydown", handler);
 		});
-		return { toggleActive };
-	},
-	extendNode(node, ctx) {
-		node.isActive = () => ctx.tree?.activeId === node.id;
-		node.toggleActive = (active) => {
-			ctx.tree.toggleActive(node.id, active);
-		};
+		return { emitNodeClick };
 	}
 };
-var src_default = keyboardNavigation;
+var src_default = keyboardPlugin;
 
 //#endregion
-export { src_default as default, keyboardNavigation };
+export { src_default as default, keyboardPlugin };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@splicetree/plugin-keyboard",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "author": {
     "email": "michael.cocova@gmail.com",
     "name": "Michael Cocova"
@@ -23,7 +23,7 @@
     "access": "public"
   },
   "devDependencies": {
-    "@splicetree/core": "0.0.1"
+    "@splicetree/core": "0.1.1"
   },
   "scripts": {
     "dev": "tsdown --watch",

package/src/index.ts

@@ -1,252 +1,147 @@
 import type { SpliceTreePlugin, SpliceTreePluginContext } from '@splicetree/core'
 import '@splicetree/core'
 
+interface KeyboardKeymap {
+  up?: string
+  down?: string
+  left?: string
+  right?: string
+}
 type KeyboardTargetType = HTMLElement | string | null | undefined
 type KeyboardTarget = KeyboardTargetType | (() => KeyboardTargetType)
+
+interface Modifiers {
+  shift: boolean
+  ctrl: boolean
+  meta: boolean
+  alt: boolean
+}
+
 declare module '@splicetree/core' {
-  export interface UseSpliceTreeOptions {
-    /**
-     * 默认激活节点 ID
-     * @default undefined
-     */
-    defaultActive?: string
-    /**
-     * 是否自动监听键盘事件
-     * 开启后，插件会自动监听键盘事件
-     * 关闭后，需要手动调用 `listenKeyboard` 方法监听键盘事件
-     * @default true
-     */
-    autoListenKeyboard?: boolean
-    /**
-     * 键盘导航快捷键
-     * @default { expand: 'ArrowRight', collapse: 'ArrowLeft', next: 'ArrowDown', prev: 'ArrowUp' }
-     */
-    keymap?: {
-      expand?: string
-      collapse?: string
-      next?: string
-      prev?: string
+  export interface SpliceTreeConfiguration {
+    keyboard?: {
+      autoListen?: boolean
+      target?: KeyboardTarget
+      keymap?: KeyboardKeymap
     }
-    /**
-     * 键盘导航目标元素
-     * @default document.body
-     */
-    keyboardTarget?: KeyboardTarget
   }
-
-  /**
-   * 实例扩展（Keyboard）
-   * - activeId：当前激活的节点 id
-   * - toggleActive：切换或显式设置某节点的激活态
-   */
-  interface SpliceTreeInstance {
-    /**
-     * 当前激活的节点 id（未激活时为 undefined）
-     */
-    activeId?: string
-    /**
-     * 切换或显式设置某节点的激活态
-     * @param id 节点 id
-     * @param active 不传表示切换；true/false 表示显式设置
-     */
-    toggleActive: (id: string, active?: boolean) => void
+  export interface SpliceTreeEventPayloadMap {
+    'input:direction': {
+      direction: 'up' | 'down' | 'left' | 'right'
+      modifiers: Modifiers
+    }
+    'input:node-click': {
+      nodeId: string
+      modifiers: Modifiers
+    }
   }
-
-  /**
-   * 节点扩展（Keyboard）
-   * - isActive：当前节点是否激活
-   * - toggleActive：切换当前节点的激活态
-   */
-  interface SpliceTreeNode {
-    /**
-     * 当前节点是否为激活态
-     */
-    isActive: () => boolean
-    /**
-     * 切换当前节点的激活态
-     * @param active 不传表示切换；true/false 表示显式设置
-     */
-    toggleActive: (active?: boolean) => void
+  export interface SpliceTreeInstance {
+    emitNodeClick: (nodeId: string, e: MouseEvent) => void
   }
 }
-
-/**
- * 解析键盘监听目标元素
- * 支持传入选择器、元素实例或函数
- */
-function resolveKeyboardTarget(targe?: KeyboardTarget): HTMLElement | null {
-  if (typeof targe === 'string') {
-    return document.querySelector(targe)
+function resolveTarget(target?: KeyboardTarget): HTMLElement | null {
+  if (typeof target === 'string') {
+    return document.querySelector(target)
   }
-  if (targe instanceof HTMLElement) {
-    return targe
+  if (target instanceof HTMLElement) {
+    return target
   }
-  if (typeof targe === 'function') {
-    return resolveKeyboardTarget(targe?.())
+  if (typeof target === 'function') {
+    return resolveTarget(target())
   }
   return null
 }
-export const keyboardNavigation: SpliceTreePlugin = {
+
+function getModifiers(e: KeyboardEvent | MouseEvent) {
+  return {
+    shift: e.shiftKey,
+    ctrl: e.ctrlKey,
+    meta: e.metaKey,
+    alt: e.altKey,
+  }
+}
+
+export const keyboardPlugin: SpliceTreePlugin = {
   name: 'keyboard',
-  /**
-   * 键盘导航插件
-   * - 提供 activeId 概念与切换 API
-   * - 支持上下移动、展开/收起与进入子级
-   * - 自动或自定义监听目标元素的键盘事件
-   */
+
   setup(ctx: SpliceTreePluginContext) {
-    const { defaultActive, autoListenKeyboard = true, keyboardTarget, keymap } = ctx.options
-    let activeId: string | undefined = defaultActive
-
-    Object.defineProperty(ctx.tree, 'activeId', {
-      get() {
-        return activeId
-      },
-      configurable: true,
-      enumerable: true,
-    })
-
-    /**
-     * 切换或设置激活节点
-     * 更新后派发 visibility 事件以刷新视图
-     * @param id 节点 id
-     * @param active 不传表示切换；true/false 表示显式设置
-     */
-    const toggleActive = (id: string, active?: boolean) => {
-      if (active === undefined) {
-        activeId = activeId === id ? undefined : id
-      } else {
-        if (active)
-          activeId = id
-        else if (activeId === id)
-          activeId = undefined
-      }
-      ctx.events.emit({ name: 'visibility', keys: ctx.tree.expandedKeys() })
+    const config = (ctx.options?.configuration?.keyboard ?? {}) as {
+      autoListen?: boolean
+      target?: KeyboardTarget
+      keymap?: KeyboardKeymap
     }
+    const autoListenKeyboard = config.autoListen ?? true
+    const keyboardTarget = config.target
+    const keymap = config.keymap
 
-    /**
-     * 按可见序列移动激活项
-     * @param delta 移动步长（-1 上一个，1 下一个）
-     */
-    const moveActive = (delta: number) => {
-      const items = ctx.tree.items()
-      if (!items.length) {
-        return
-      }
-      const idx = activeId ? items.findIndex(n => n.id === activeId) : -1
-      const next = Math.max(0, Math.min(items.length - 1, (idx < 0 ? 0 : idx + delta)))
-      activeId = items[next]?.id
-      ctx.events.emit({ name: 'visibility', keys: ctx.tree.expandedKeys() })
+    const keys = {
+      up: keymap?.up ?? 'ArrowUp',
+      down: keymap?.down ?? 'ArrowDown',
+      left: keymap?.left ?? 'ArrowLeft',
+      right: keymap?.right ?? 'ArrowRight',
     }
 
-    /**
-     * 激活上一个可见节点
-     */
-    const keyUp = () => moveActive(-1)
-    /**
-     * 激活下一个可见节点
-     */
-    const keyDown = () => moveActive(1)
-    /**
-     * 左方向键：优先收起；否则激活父节点
-     */
-    const keyLeft = () => {
-      if (!activeId) {
-        return
-      }
-      const node = ctx.tree.getNode(activeId)
-      if (!node) {
-        return
-      }
-      if (ctx.tree.isExpanded(node.id)) {
-        ctx.tree.collapse(node.id)
-      } else if (node.getParent()?.id) {
-        activeId = node.getParent()!.id
-      }
-      ctx.events.emit({ name: 'visibility', keys: ctx.tree.expandedKeys() })
-    }
-    /**
-     * 右方向键：优先展开；已展开则进入第一个子节点
-     */
-    const keyRight = () => {
-      if (!activeId) {
-        return
-      }
-      const node = ctx.tree.getNode(activeId)
-      if (!node) {
-        return
-      }
-      if (!ctx.tree.isExpanded(node.id)) {
-        ctx.tree.expand(node.id)
-      } else {
-        const first = node.getChildren()[0]
-        if (first) {
-          activeId = first.id
-        }
-      }
-      ctx.events.emit({ name: 'visibility', keys: ctx.tree.expandedKeys() })
+    const emitDirection = (direction: 'up' | 'down' | 'left' | 'right', e: KeyboardEvent) => {
+      ctx.events.emit({
+        name: 'input:direction',
+        direction,
+        modifiers: getModifiers(e),
+      })
     }
-    /**
-     * 键盘按下事件处理
-     * - 根据 keymap 映射调用对应处理函数
-     * - 自动阻止默认行为以避免滚动
-     */
+
     const onKeydown = (e: KeyboardEvent) => {
-      const kExpand = keymap?.expand ?? 'ArrowRight'
-      const kCollapse = keymap?.collapse ?? 'ArrowLeft'
-      const kNext = keymap?.next ?? 'ArrowDown'
-      const kPrev = keymap?.prev ?? 'ArrowUp'
-      const key = e.key
-      if (key === kPrev) {
-        e.preventDefault()
-        keyUp()
-        return
-      }
-      if (key === kNext) {
-        e.preventDefault()
-        keyDown()
-        return
-      }
-      if (key === kCollapse) {
-        e.preventDefault()
-        keyLeft()
-        return
-      }
-      if (key === kExpand) {
-        e.preventDefault()
-        keyRight()
+      switch (e.key) {
+        case keys.up:
+          e.preventDefault()
+          emitDirection('up', e)
+          break
+        case keys.down:
+          e.preventDefault()
+          emitDirection('down', e)
+          break
+        case keys.left:
+          e.preventDefault()
+          emitDirection('left', e)
+          break
+        case keys.right:
+          e.preventDefault()
+          emitDirection('right', e)
+          break
       }
     }
+
+    const emitNodeClick = (nodeId: string, e: MouseEvent) => {
+      ctx.events.emit({
+        name: 'input:node-click',
+        nodeId,
+        modifiers: getModifiers(e),
+      })
+    }
+
     if (autoListenKeyboard && typeof document !== 'undefined') {
       setTimeout(() => {
-        const root = resolveKeyboardTarget(keyboardTarget)
-        if (root) {
-          root.setAttribute('tabindex', '0')
-          root?.focus?.()
+        const root = resolveTarget(keyboardTarget)
+        if (!root) {
+          return
         }
+
+        root.setAttribute('tabindex', '0')
+
         const handler = (e: KeyboardEvent) => {
           const active = document.activeElement
-          // 仅当 activeElement 在树容器内时触发
-          if (!root || root.contains(active)) {
+          if (root.contains(active)) {
             onKeydown(e)
           }
         }
+
         document.addEventListener('keydown', handler)
       })
     }
-    return { toggleActive }
-  },
-  /**
-   * 为节点扩展激活态判断方法
-   * - isActive：是否为当前激活项
-   * - toggleActive：切换当前节点的激活态
-   */
-  extendNode(node, ctx) {
-    node.isActive = () => ctx.tree?.activeId === node.id
-    node.toggleActive = (active?: boolean) => {
-      ctx.tree.toggleActive(node.id, active)
+
+    return {
+      emitNodeClick,
     }
   },
 }
 
-export default keyboardNavigation
+export default keyboardPlugin