@octane-xplat/keyboard 0.0.1 → 0.17.0

package/src/focus-source.android.ts

@@ -0,0 +1,173 @@
+import { Utils } from '@nativescript/core'
+import { android } from '@octane-xplat/platform/android'
+import type { KeyboardWindowSource } from '@octane-xplat/platform/keyboard-registry'
+import type {
+	FocusedInputState,
+	FocusedInputScrollOwner,
+} from '@octane-xplat/platform/focused-input-state'
+
+import type { KeyboardRect } from '@octane-xplat/platform/keyboard-geometry'
+import { emptyFocus, focusSelection } from './focus-geometry'
+import { focusPublisher } from './focus-publish'
+import { keyboardNativeScope } from './native-scope'
+
+export const focusRechecks = new Map<object, () => void>()
+const dip = (value: number) => Utils.layout.toDeviceIndependentPixels(value)
+const location = (view: any) => {
+	const xy = (Array as any).create('int', 2)
+	view.getLocationOnScreen(xy)
+	return { x: xy[0], y: xy[1] }
+}
+
+const bounds = (
+	view: any,
+	decor: any,
+	box = { x: 0, y: 0, width: view.getWidth(), height: view.getHeight() },
+): KeyboardRect | null => {
+	const origin = location(decor)
+	if (typeof view.transformMatrixToGlobal === 'function') {
+		const matrix = new android.graphics.Matrix()
+		view.transformMatrixToGlobal(matrix)
+		const rect = new android.graphics.RectF(box.x, box.y, box.x + box.width, box.y + box.height)
+		matrix.mapRect(rect)
+		return {
+			x: dip(rect.left - origin.x),
+			y: dip(rect.top - origin.y),
+			width: dip(rect.width()),
+			height: dip(rect.height()),
+		}
+	}
+	for (let parent = view; parent?.getMatrix; parent = parent.getParent?.()) {
+		if (!parent.getMatrix().isIdentity()) {
+			return null
+		}
+	}
+	const at = location(view)
+	return {
+		x: dip(at.x - origin.x + box.x),
+		y: dip(at.y - origin.y + box.y),
+		width: dip(box.width),
+		height: dip(box.height),
+	}
+}
+
+/** Own multicast draw listeners; selection/layout changes never require text reads. */
+export const observeFocusedInput: KeyboardWindowSource<FocusedInputState> = (key, notify) => {
+	const decor = key as any,
+		scope = keyboardNativeScope(),
+		publish = focusPublisher(notify)
+	let active = true
+	scope.defer(() => {
+		active = false
+	})
+	try {
+		const read = () => {
+			if (!active) {
+				return
+			}
+			const state = emptyFocus(
+				{ x: 0, y: 0, width: dip(decor.getWidth()), height: dip(decor.getHeight()) },
+				'insertion-line',
+			)
+			const input = decor.findFocus?.()
+			if (
+				!input ||
+				!(input instanceof android.widget.EditText) ||
+				typeof input.getSelectionEnd !== 'function' ||
+				input.getRootView() !== decor ||
+				!input.isAttachedToWindow()
+			) {
+				publish(state)
+				return
+			}
+			const selection = focusSelection(input.getSelectionStart(), input.getSelectionEnd())
+			const layout = input.getLayout?.()
+			let caret: KeyboardRect | null = null
+			if (selection && layout?.getLineCount() > 0) {
+				const end = Math.min(selection.end, layout.getLineEnd(layout.getLineCount() - 1))
+				const line = layout.getLineForOffset(end)
+				caret = bounds(input, decor, {
+					x: layout.getPrimaryHorizontal(end) + input.getTotalPaddingLeft() - input.getScrollX(),
+					y: layout.getLineTop(line) + input.getTotalPaddingTop() - input.getScrollY(),
+					width: 1,
+					height: layout.getLineBottom(line) - layout.getLineTop(line),
+				})
+			}
+			const nested = (globalThis as any).androidx?.core?.widget?.NestedScrollView,
+				mason = (globalThis as any).org?.nativescript?.mason?.masonkit?.TwoDScrollView
+			const owners: FocusedInputScrollOwner[] = []
+			for (let parent: any = input.getParent(); parent?.getParent; parent = parent.getParent()) {
+				const masonScroll = !!mason && parent instanceof mason
+				if (
+					!(parent instanceof android.widget.ScrollView) &&
+					!(nested && parent instanceof nested) &&
+					!masonScroll
+				) {
+					continue
+				}
+
+				const rect = bounds(parent, decor),
+					child = parent.getChildAt(0)
+
+				if (!rect || !child) {
+					continue
+				}
+
+				owners.push({
+					id: parent,
+					rect,
+					offsetY: dip(parent.getScrollY()),
+					minOffsetY: 0,
+					maxOffsetY: dip(
+						masonScroll
+							? Math.max(0, parent.computeVerticalScrollRange() - parent.getHeight())
+							: Math.max(
+									0,
+									child.getHeight() +
+										parent.getPaddingTop() +
+										parent.getPaddingBottom() -
+										parent.getHeight(),
+								),
+					),
+				})
+			}
+			const box = bounds(input, decor)
+			publish({
+				...state,
+				input,
+				inputRect: box,
+				caretRect: caret,
+				selection,
+				scrollOwners: owners,
+				capabilities: {
+					inputBounds: !!box,
+					caretBounds: caret ? 'insertion-line' : 'none',
+					selection: !!selection,
+				},
+			})
+		}
+
+		const listener = new android.view.ViewTreeObserver.OnPreDrawListener({
+			onPreDraw() {
+				read()
+				return true
+			},
+		})
+
+		decor.getViewTreeObserver().addOnPreDrawListener(listener)
+		scope.defer(() => {
+			const tree = decor.getViewTreeObserver()
+			if (tree.isAlive()) {
+				tree.removeOnPreDrawListener(listener)
+			}
+		})
+
+		focusRechecks.set(key, read)
+		scope.defer(() => focusRechecks.delete(key))
+		read()
+		return () => scope.release()
+	} catch (error) {
+		scope.release()
+		throw error
+	}
+}

package/src/focus-source.ios.ts

@@ -0,0 +1,202 @@
+import {
+	NSObject,
+	CADisplayLink,
+	NSRunLoop,
+	NSNotificationCenter,
+	NSOperationQueue,
+	UIScrollView,
+} from '@octane-xplat/platform/ios'
+
+import type { KeyboardWindowSource } from '@octane-xplat/platform/keyboard-registry'
+import type {
+	FocusedInputState,
+	FocusedInputScrollOwner,
+} from '@octane-xplat/platform/focused-input-state'
+
+import { focusRect, focusSelection, emptyFocus } from './focus-geometry'
+import { focusPublisher } from './focus-publish'
+import { keyboardNativeScope } from './native-scope'
+
+/** MasonKit scroll containers are MasonUIView, not UIScrollView; mirror
+ * MasonUIView.swift's vertical scrollability rule. */
+const masonScrollsY = (view: any) => {
+	const Mason = (globalThis as any).MasonUIView
+	if (!Mason || !(view instanceof Mason)) {
+		return false
+	}
+	const range = () => view.contentSize.height > view.bounds.size.height
+	switch (view.overflowY) {
+		case 2:
+			return true
+		case 4:
+			return range()
+		case 0:
+			return !!view.isScrollContainer && range()
+		default:
+			return false
+	}
+}
+
+export const focusRechecks = new Map<object, () => void>()
+let Target: any
+const targetFor = (read: () => void) => {
+	if (!Target) {
+		const interop = (globalThis as any).interop
+		Target = (NSObject as any).extend(
+			{
+				['tick:'](this: any) {
+					this.read?.()
+				},
+			},
+			{ exposedMethods: { 'tick:': { returns: interop.types.void, params: [CADisplayLink] } } },
+		)
+	}
+	const target = Target.new()
+	target.read = read
+	return target
+}
+
+const editing = (view: any): boolean =>
+	!!view?.isFirstResponder && typeof view.caretRectForPosition === 'function'
+
+const find = (view: any): any => {
+	if (editing(view)) {
+		return view
+	}
+	const children = view?.subviews
+	for (let index = 0; index < (children?.count ?? 0); index++) {
+		const found = find(children.objectAtIndex(index))
+		if (found) {
+			return found
+		}
+	}
+	return null
+}
+
+/** Poll caret/layout while editing; standard UIKit notifications change identity.
+ * No delegate replacement and no input text reads. */
+export const observeFocusedInput: KeyboardWindowSource<FocusedInputState> = (key, notify) => {
+	const window = key as any,
+		scope = keyboardNativeScope(),
+		publish = focusPublisher(notify)
+	let active = true,
+		input = find(window)
+	scope.defer(() => {
+		active = false
+	})
+	try {
+		const read = () => {
+			if (!active) {
+				return
+			}
+			if (input && (!editing(input) || input.window !== window)) {
+				input = null
+			}
+			const state = emptyFocus(focusRect(window.bounds), 'native-rect')
+			if (!input) {
+				publish(state)
+				return
+			}
+			const box = input.hidden ? null : focusRect(input.convertRectToView(input.bounds, window))
+			const range = input.selectedTextRange
+			const selection = range
+				? focusSelection(
+						Number(input.offsetFromPositionToPosition(input.beginningOfDocument, range.start)),
+						Number(input.offsetFromPositionToPosition(input.beginningOfDocument, range.end)),
+					)
+				: null
+			const caret = range
+				? focusRect(input.convertRectToView(input.caretRectForPosition(range.end), window))
+				: null
+			const owners: FocusedInputScrollOwner[] = []
+			for (let view = input; view; view = view.superview) {
+				const mason = masonScrollsY(view)
+				if (!(view instanceof UIScrollView) && !mason) {
+					continue
+				}
+
+				const rect = focusRect(view.convertRectToView(view.bounds, window))
+				if (!rect) {
+					continue
+				}
+
+				if (mason) {
+					owners.push({
+						id: view,
+						rect,
+						offsetY: view.mason_scrollTop,
+						minOffsetY: 0,
+						maxOffsetY: Math.max(0, view.mason_scrollHeight - view.mason_clientHeight),
+					})
+					continue
+				}
+
+				const inset = view.adjustedContentInset ?? view.contentInset
+				const min = -(inset?.top ?? 0)
+				owners.push({
+					id: view,
+					rect,
+					offsetY: view.contentOffset.y,
+					minOffsetY: min,
+					maxOffsetY: Math.max(
+						min,
+						view.contentSize.height - view.bounds.size.height + (inset?.bottom ?? 0),
+					),
+				})
+			}
+			publish({
+				...state,
+				input,
+				inputRect: box,
+				caretRect: caret?.height ? caret : null,
+				selection,
+				scrollOwners: owners,
+				capabilities: {
+					inputBounds: !!box,
+					caretBounds: caret?.height ? 'native-rect' : 'none',
+					selection: !!selection,
+				},
+			})
+		}
+
+		const center = NSNotificationCenter.defaultCenter
+		for (const name of [
+			UITextFieldTextDidBeginEditingNotification,
+			UITextViewTextDidBeginEditingNotification,
+			UITextFieldTextDidEndEditingNotification,
+			UITextViewTextDidEndEditingNotification,
+		]) {
+			const token = center.addObserverForNameObjectQueueUsingBlock(
+				name,
+				null,
+				NSOperationQueue.mainQueue,
+				(note: any) => {
+					const candidate = note.object
+					if (candidate?.window === window && editing(candidate)) {
+						input = candidate
+					} else if (candidate === input) {
+						input = null
+					}
+				},
+			)
+
+			scope.defer(() => center.removeObserver(token))
+		}
+
+		const target = targetFor(read)
+		const link = CADisplayLink.displayLinkWithTargetSelector(target, 'tick:')
+		scope.defer(() => {
+			target.read = undefined
+			link.invalidate()
+		})
+
+		link.addToRunLoopForMode(NSRunLoop.mainRunLoop, 'kCFRunLoopCommonModes')
+		focusRechecks.set(key, read)
+		scope.defer(() => focusRechecks.delete(key))
+		read()
+		return () => scope.release()
+	} catch (error) {
+		scope.release()
+		throw error
+	}
+}

package/src/focus-source.macos.ts

@@ -0,0 +1,113 @@
+import { NSScrollView } from '@octane-xplat/platform/macos'
+import type { KeyboardWindowSource } from '@octane-xplat/platform/keyboard-registry'
+import type {
+	FocusedInputState,
+	FocusedInputScrollOwner,
+} from '@octane-xplat/platform/focused-input-state'
+
+import { emptyFocus, focusRect, focusSelection } from './focus-geometry'
+import { focusPublisher } from './focus-publish'
+import { keyboardNativeScope } from './native-scope'
+import { startFocusClock } from './focus-clock'
+
+export const focusRechecks = new Map<object, () => void>()
+const flipped = (view: any): boolean =>
+	typeof view?.isFlipped === 'function' ? view.isFlipped() : !!view?.isFlipped
+
+/** AppKit input/field-editor geometry, normalized to content-window top-left. */
+export const observeFocusedInput: KeyboardWindowSource<FocusedInputState> = (key, notify) => {
+	const window = key as any,
+		scope = keyboardNativeScope(),
+		publish = focusPublisher(notify)
+	let active = true
+	scope.defer(() => {
+		active = false
+	})
+	try {
+		const read = () => {
+			if (!active) {
+				return
+			}
+			const root = window.contentView
+			const box = focusRect(root?.bounds)
+			const state = emptyFocus(box && { ...box, x: 0, y: 0 }, 'native-rect')
+			const editor = window.firstResponder
+			if (!root || !editor || typeof editor.firstRectForCharacterRangeActualRange !== 'function') {
+				publish(state)
+				return
+			}
+			const candidate = editor.delegate
+			const input =
+				candidate?.window === window && typeof candidate.convertRectToView === 'function'
+					? candidate
+					: editor
+			if (input.window !== window) {
+				publish(state)
+				return
+			}
+			const normalize = (value: any) => {
+				const rect = focusRect(value)
+				return (
+					rect &&
+					(flipped(root) ? rect : { ...rect, y: root.bounds.size.height - rect.y - rect.height })
+				)
+			}
+			const range = editor.selectedRange
+			const selection = range
+				? focusSelection(Number(range.location), Number(range.location) + Number(range.length))
+				: null
+			const caretScreen = selection
+				? editor.firstRectForCharacterRangeActualRange({ location: selection.end, length: 0 }, null)
+				: null
+			const caret = caretScreen
+				? normalize(root.convertRectFromView(window.convertRectFromScreen(caretScreen), null))
+				: null
+			const owners: FocusedInputScrollOwner[] = []
+			for (let parent = input; parent; parent = parent.superview) {
+				if (!(parent instanceof NSScrollView) || !parent.documentView) {
+					continue
+				}
+
+				const clip = parent.contentView,
+					content = parent.documentView
+
+				const rect = normalize(clip.convertRectToView(clip.bounds, root))
+				if (!rect) {
+					continue
+				}
+
+				const max = Math.max(0, content.bounds.size.height - clip.bounds.size.height)
+				owners.push({
+					id: parent,
+					rect,
+					offsetY: flipped(content) ? clip.bounds.origin.y : max - clip.bounds.origin.y,
+					minOffsetY: 0,
+					maxOffsetY: max,
+				})
+			}
+			const inputRect = normalize(input.convertRectToView(input.bounds, root))
+			publish({
+				...state,
+				input,
+				inputRect,
+				caretRect: caret?.height ? caret : null,
+				selection,
+				scrollOwners: owners,
+				capabilities: {
+					inputBounds: !!inputRect,
+					caretBounds: caret?.height ? 'native-rect' : 'none',
+					selection: !!selection,
+				},
+			})
+		}
+
+		scope.defer(startFocusClock(read))
+		focusRechecks.set(key, read)
+		scope.defer(() => focusRechecks.delete(key))
+		read()
+		return () => scope.release()
+	} catch (error) {
+		scope.release()
+		throw error
+	}
+}

package/src/focus-source.ts

@@ -0,0 +1,12 @@
+import type { KeyboardWindowSource } from '@octane-xplat/platform/keyboard-registry'
+import type { FocusedInputState } from '@octane-xplat/platform/focused-input-state'
+import { unknownFocusedInputState } from '@octane-xplat/platform/focused-input-state'
+
+/** @internal Default adapter is explicitly unsupported. */
+export const observeFocusedInput: KeyboardWindowSource<FocusedInputState> = (_window, notify) => {
+	notify(unknownFocusedInputState())
+	return () => {}
+}
+
+/** @internal Active readers install a measurement callback per actual window. */
+export const focusRechecks = new Map<object, () => void>()

package/src/focus-source.web.ts

@@ -0,0 +1,157 @@
+import type { KeyboardWindowSource } from '@octane-xplat/platform/keyboard-registry'
+import type {
+	FocusedInputState,
+	FocusedInputScrollOwner,
+} from '@octane-xplat/platform/focused-input-state'
+
+import { unknownFocusedInputState } from '@octane-xplat/platform/focused-input-state'
+import { emptyFocus, focusSelection } from './focus-geometry'
+import { focusPublisher } from './focus-publish'
+import { keyboardNativeScope } from './native-scope'
+
+export const focusRechecks = new Map<object, () => void>()
+const parentOf = (view: HTMLElement): HTMLElement | null =>
+	view.assignedSlot ??
+	view.parentElement ??
+	((view.getRootNode() as ShadowRoot).host as HTMLElement | undefined) ??
+	null
+
+const rect = (value: DOMRect) => ({
+	x: value.x,
+	y: value.y,
+	width: value.width,
+	height: value.height,
+})
+
+const focused = (document: Document): Element | null => {
+	let input = document.activeElement
+	while (input?.shadowRoot?.activeElement) {
+		input = input.shadowRoot.activeElement
+	}
+	return input
+}
+
+/** DOM geometry and selection metadata; value/textContent are never accessed. */
+export const observeFocusedInput: KeyboardWindowSource<FocusedInputState> = (key, notify) => {
+	const document = key as Document,
+		window = document.defaultView!
+	const scope = keyboardNativeScope(),
+		publish = focusPublisher(notify)
+	const currentDocument = () => {
+		try {
+			return !window.closed && window.document === document
+		} catch {
+			return false
+		}
+	}
+	let active = true,
+		frame = 0
+	scope.defer(() => {
+		active = false
+		if (currentDocument()) {
+			window.cancelAnimationFrame(frame)
+		}
+	})
+	try {
+		const read = () => {
+			if (!active) {
+				return
+			}
+			if (!currentDocument()) {
+				scope.release()
+				publish(unknownFocusedInputState())
+				return
+			}
+			const state = emptyFocus(
+				{ x: 0, y: 0, width: window.innerWidth, height: window.innerHeight },
+				'none',
+			)
+			const input = focused(document) as HTMLElement | null
+			const textInput =
+				input?.tagName === 'INPUT' &&
+				['text', 'search', 'url', 'tel', 'email', 'password', 'number'].includes(
+					(input as HTMLInputElement).type,
+				)
+			if (
+				!input?.isConnected ||
+				!(textInput || input.tagName === 'TEXTAREA' || input.isContentEditable)
+			) {
+				publish(state)
+				return
+			}
+			const control = input as HTMLInputElement | HTMLTextAreaElement
+			const selection =
+				typeof control.selectionStart === 'number' && typeof control.selectionEnd === 'number'
+					? focusSelection(control.selectionStart, control.selectionEnd)
+					: null
+			let caret: FocusedInputState['caretRect'] = null
+			if (input.isContentEditable) {
+				const selected = document.getSelection()
+				if (selected?.rangeCount && input.contains(selected.focusNode)) {
+					const range = selected.getRangeAt(0).cloneRange()
+					range.collapse(false)
+					const value = range.getBoundingClientRect()
+					if (value.height > 0) {
+						caret = rect(value)
+					}
+				}
+			}
+			const owners: FocusedInputScrollOwner[] = []
+			for (let parent = parentOf(input); parent; parent = parentOf(parent)) {
+				const overflow = window.getComputedStyle(parent).overflowY
+				if (
+					!['auto', 'scroll', 'overlay'].includes(overflow) &&
+					parent !== document.scrollingElement
+				) {
+					continue
+				}
+
+				const box = parent.getBoundingClientRect()
+				owners.push({
+					id: parent,
+					rect:
+						parent === document.scrollingElement
+							? { x: 0, y: 0, width: window.innerWidth, height: window.innerHeight }
+							: {
+									x: box.x + parent.clientLeft,
+									y: box.y + parent.clientTop,
+									width: parent.clientWidth,
+									height: parent.clientHeight,
+								},
+					offsetY: parent.scrollTop,
+					minOffsetY: 0,
+					maxOffsetY: Math.max(0, parent.scrollHeight - parent.clientHeight),
+				})
+			}
+			publish({
+				...state,
+				input,
+				inputRect: rect(input.getBoundingClientRect()),
+				caretRect: caret,
+				selection,
+				scrollOwners: owners,
+				capabilities: {
+					inputBounds: true,
+					caretBounds: caret ? 'native-rect' : 'none',
+					selection: !!selection,
+				},
+			})
+		}
+
+		const tick = () => {
+			read()
+			if (active) {
+				frame = window.requestAnimationFrame(tick)
+			}
+		}
+
+		focusRechecks.set(key, read)
+		scope.defer(() => focusRechecks.delete(key))
+		read()
+		frame = window.requestAnimationFrame(tick)
+		return () => scope.release()
+	} catch (error) {
+		scope.release()
+		throw error
+	}
+}

package/src/focus-types.ts

@@ -0,0 +1,19 @@
+import type { FocusedInputState } from '@octane-xplat/platform/focused-input-state'
+
+/** Focused input geometry in device-independent window coordinates. Identity
+ * and scroll owners are opaque native/DOM handles. No text contents are read.
+ * Unsupported targets return null geometry and false capabilities. */
+export type FocusedInputSnapshot = FocusedInputState
+/** A vertical scroll viewport containing the input, nearest owner first. */
+export type { FocusedInputScrollOwner } from '@octane-xplat/platform/focused-input-state'
+
+/** Separate focus/selection geometry from software-keyboard movement. */
+export interface FocusedInputService {
+	/** Cached read; does not start observation. */
+	getSnapshot(host: object): FocusedInputSnapshot
+	/** Observe identity, selection and layout changes; release on host removal.
+	 * Geometry callbacks can occur each frame during native layout movement. */
+	subscribe(host: object, listener: (snapshot: FocusedInputSnapshot) => void): () => void
+	/** Refresh an actively observed host. No-op without a reader. */
+	recheck(host: object): void
+}