Download src/ink/focus.ts from chenbhao/codev: direct link, hf CLI and curl.
- Browser
- Download file 5.14 kB
-
https://huggingface.co/chenbhao/codev/resolve/main/src/ink/focus.ts
- Command line
-
hf download hf://chenbhao/codev/src/ink/focus.ts
-
curl -L -o focus.ts https://huggingface.co/chenbhao/codev/resolve/main/src/ink/focus.ts
5.14 kB
| import type { DOMElement } from './dom.js' | |
| import { FocusEvent } from './events/focus-event.js' | |
| const MAX_FOCUS_STACK = 32 | |
| /** | |
| * DOM-like focus manager for the Ink terminal UI. | |
| * | |
| * Pure state — tracks activeElement and a focus stack. Has no reference | |
| * to the tree; callers pass the root when tree walks are needed. | |
| * | |
| * Stored on the root DOMElement so any node can reach it by walking | |
| * parentNode (like browser's `node.ownerDocument`). | |
| */ | |
| export class FocusManager { | |
| activeElement: DOMElement | null = null | |
| private dispatchFocusEvent: (target: DOMElement, event: FocusEvent) => boolean | |
| private enabled = true | |
| private focusStack: DOMElement[] = [] | |
| constructor( | |
| dispatchFocusEvent: (target: DOMElement, event: FocusEvent) => boolean, | |
| ) { | |
| this.dispatchFocusEvent = dispatchFocusEvent | |
| } | |
| focus(node: DOMElement): void { | |
| if (node === this.activeElement) return | |
| if (!this.enabled) return | |
| const previous = this.activeElement | |
| if (previous) { | |
| // Deduplicate before pushing to prevent unbounded growth from Tab cycling | |
| const idx = this.focusStack.indexOf(previous) | |
| if (idx !== -1) this.focusStack.splice(idx, 1) | |
| this.focusStack.push(previous) | |
| if (this.focusStack.length > MAX_FOCUS_STACK) this.focusStack.shift() | |
| this.dispatchFocusEvent(previous, new FocusEvent('blur', node)) | |
| } | |
| this.activeElement = node | |
| this.dispatchFocusEvent(node, new FocusEvent('focus', previous)) | |
| } | |
| blur(): void { | |
| if (!this.activeElement) return | |
| const previous = this.activeElement | |
| this.activeElement = null | |
| this.dispatchFocusEvent(previous, new FocusEvent('blur', null)) | |
| } | |
| /** | |
| * Called by the reconciler when a node is removed from the tree. | |
| * Handles both the exact node and any focused descendant within | |
| * the removed subtree. Dispatches blur and restores focus from stack. | |
| */ | |
| handleNodeRemoved(node: DOMElement, root: DOMElement): void { | |
| // Remove the node and any descendants from the stack | |
| this.focusStack = this.focusStack.filter( | |
| n => n !== node && isInTree(n, root), | |
| ) | |
| // Check if activeElement is the removed node OR a descendant | |
| if (!this.activeElement) return | |
| if (this.activeElement !== node && isInTree(this.activeElement, root)) { | |
| return | |
| } | |
| const removed = this.activeElement | |
| this.activeElement = null | |
| this.dispatchFocusEvent(removed, new FocusEvent('blur', null)) | |
| // Restore focus to the most recent still-mounted element | |
| while (this.focusStack.length > 0) { | |
| const candidate = this.focusStack.pop()! | |
| if (isInTree(candidate, root)) { | |
| this.activeElement = candidate | |
| this.dispatchFocusEvent(candidate, new FocusEvent('focus', removed)) | |
| return | |
| } | |
| } | |
| } | |
| handleAutoFocus(node: DOMElement): void { | |
| this.focus(node) | |
| } | |
| handleClickFocus(node: DOMElement): void { | |
| const tabIndex = node.attributes['tabIndex'] | |
| if (typeof tabIndex !== 'number') return | |
| this.focus(node) | |
| } | |
| enable(): void { | |
| this.enabled = true | |
| } | |
| disable(): void { | |
| this.enabled = false | |
| } | |
| focusNext(root: DOMElement): void { | |
| this.moveFocus(1, root) | |
| } | |
| focusPrevious(root: DOMElement): void { | |
| this.moveFocus(-1, root) | |
| } | |
| private moveFocus(direction: 1 | -1, root: DOMElement): void { | |
| if (!this.enabled) return | |
| const tabbable = collectTabbable(root) | |
| if (tabbable.length === 0) return | |
| const currentIndex = this.activeElement | |
| ? tabbable.indexOf(this.activeElement) | |
| : -1 | |
| const nextIndex = | |
| currentIndex === -1 | |
| ? direction === 1 | |
| ? 0 | |
| : tabbable.length - 1 | |
| : (currentIndex + direction + tabbable.length) % tabbable.length | |
| const next = tabbable[nextIndex] | |
| if (next) { | |
| this.focus(next) | |
| } | |
| } | |
| } | |
| function collectTabbable(root: DOMElement): DOMElement[] { | |
| const result: DOMElement[] = [] | |
| walkTree(root, result) | |
| return result | |
| } | |
| function walkTree(node: DOMElement, result: DOMElement[]): void { | |
| const tabIndex = node.attributes['tabIndex'] | |
| if (typeof tabIndex === 'number' && tabIndex >= 0) { | |
| result.push(node) | |
| } | |
| for (const child of node.childNodes) { | |
| if (child.nodeName !== '#text') { | |
| walkTree(child, result) | |
| } | |
| } | |
| } | |
| function isInTree(node: DOMElement, root: DOMElement): boolean { | |
| let current: DOMElement | undefined = node | |
| while (current) { | |
| if (current === root) return true | |
| current = current.parentNode | |
| } | |
| return false | |
| } | |
| /** | |
| * Walk up to root and return it. The root is the node that holds | |
| * the FocusManager — like browser's `node.getRootNode()`. | |
| */ | |
| export function getRootNode(node: DOMElement): DOMElement { | |
| let current: DOMElement | undefined = node | |
| while (current) { | |
| if (current.focusManager) return current | |
| current = current.parentNode | |
| } | |
| throw new Error('Node is not in a tree with a FocusManager') | |
| } | |
| /** | |
| * Walk up to root and return its FocusManager. | |
| * Like browser's `node.ownerDocument` — focus belongs to the root. | |
| */ | |
| export function getFocusManager(node: DOMElement): FocusManager { | |
| return getRootNode(node).focusManager! | |
| } | |