pi-libtui 0.3.2

package/src/host/mouse-targets.ts

@@ -0,0 +1,238 @@
+import type { Component } from "@earendil-works/pi-tui";
+import { getMouseRegistryState } from "../mouse/registry.ts";
+import type {
+	LayoutBox,
+	LayoutFrame,
+	MouseRect,
+	MouseRegistry,
+	TextInteractionTarget,
+	TuiMouseEvent,
+} from "../mouse.ts";
+import { TEXT_INTERACTION_TARGET } from "../mouse.ts";
+import {
+	contains,
+	derivedChildren,
+	isComponent,
+	isRecord,
+	isRect,
+	rendererLayoutFrame,
+	terminalSize,
+} from "./pi-layout-adapter.ts";
+
+// type-boundary: Pi 0.84.2's private input and overlay members are narrowed by the validators below.
+type PiPrivateValue = unknown;
+
+type MouseHandler = (event: TuiMouseEvent) => boolean;
+
+interface OverlayEntry {
+	component: Component;
+	options?: PiPrivateValue;
+}
+
+export interface MouseTarget {
+	key: object;
+	getRect(): MouseRect | undefined;
+	containsPoint?(x: number, y: number): boolean;
+	isCurrent?(): boolean;
+	dispatch(event: TuiMouseEvent): boolean;
+	frame?: LayoutFrame;
+	textInteraction?: Component & TextInteractionTarget;
+	overlayRegion?: boolean;
+}
+
+function parseOverlayEntry(value: PiPrivateValue): OverlayEntry | undefined {
+	if (!isRecord(value) || !isComponent(value.component)) return undefined;
+	return { component: value.component, options: value.options };
+}
+
+function safeCall(handler: MouseHandler, receiver: object, event: TuiMouseEvent): boolean {
+	try {
+		return Reflect.apply(handler, receiver, [event]) === true;
+	} catch {
+		return false;
+	}
+}
+
+function mouseHandler(component: Component): MouseHandler | undefined {
+	const candidate = component as Component & { onMouse?: PiPrivateValue };
+	return typeof candidate.onMouse === "function" ? (candidate.onMouse as MouseHandler) : undefined;
+}
+
+function textInteractionTarget(component: Component): (Component & TextInteractionTarget) | undefined {
+	const candidate = component as Component & Partial<TextInteractionTarget>;
+	return candidate[TEXT_INTERACTION_TARGET] === true &&
+		typeof candidate.handleViewportInput === "function" &&
+		typeof candidate.setViewportFocus === "function"
+		? (candidate as Component & TextInteractionTarget)
+		: undefined;
+}
+
+const cachedComponentTargetBoxes = new WeakMap<LayoutFrame, Array<{ box: LayoutBox; depth: number }>>();
+const cachedComponentTargets = new WeakMap<LayoutFrame, Map<string, MouseTarget[]>>();
+
+function componentTargets(frame: LayoutFrame, x: number, y: number): MouseTarget[] {
+	let pointCache = cachedComponentTargets.get(frame);
+	if (!pointCache) {
+		pointCache = new Map();
+		cachedComponentTargets.set(frame, pointCache);
+	}
+	const point = `${x}:${y}`;
+	const cached = pointCache.get(point);
+	if (cached) return cached;
+	let candidates = cachedComponentTargetBoxes.get(frame);
+	if (!candidates) {
+		candidates = [];
+		const ancestors = new Set<object>();
+		const visit = (box: LayoutBox, depth: number): void => {
+			if (ancestors.has(box.component)) return;
+			const component = isComponent(box.component) ? box.component : undefined;
+			if (component && mouseHandler(component)) candidates?.push({ box, depth });
+			ancestors.add(box.component);
+			for (const child of derivedChildren(box)) visit(child, depth + 1);
+			ancestors.delete(box.component);
+		};
+		visit(frame.root, 0);
+		candidates.sort((left, right) => right.depth - left.depth);
+		cachedComponentTargetBoxes.set(frame, candidates);
+	}
+	const targets: MouseTarget[] = candidates
+		.filter(({ box }) => contains(box.clip, x, y) && contains(box.rect, x, y))
+		.map(({ box }) => ({
+			key: box.component,
+			frame,
+			// The layout walk already resolved this box for the current input frame.
+			// Rewalking here made dispatch quadratic and could rerender descendants.
+			getRect: () => box.rect,
+			containsPoint: (pointX, pointY) => contains(box.rect, pointX, pointY) && contains(box.clip, pointX, pointY),
+			textInteraction: isComponent(box.component) ? textInteractionTarget(box.component) : undefined,
+			dispatch: (event) => {
+				const component = isComponent(box.component) ? box.component : undefined;
+				const handler = component ? mouseHandler(component) : undefined;
+				return handler && component ? safeCall(handler, component, event) : false;
+			},
+		}));
+	if (pointCache.size >= 256) pointCache.clear();
+	pointCache.set(point, targets);
+	return targets;
+}
+
+function overlayTargets(registry: MouseRegistry, x: number, y: number): MouseTarget[] {
+	const matches: Array<{ target: MouseTarget; priority: number; order: number }> = [];
+	const regions = getMouseRegistryState(registry).regions;
+	for (let index = 0; index < regions.length; index += 1) {
+		const region = regions[index]!;
+		let rect: MouseRect | undefined;
+		try {
+			rect = region.getRect();
+		} catch {
+			continue;
+		}
+		if (!rect || !isRect(rect) || !contains(rect, x, y)) continue;
+		const target: MouseTarget = {
+			key: region,
+			overlayRegion: true,
+			isCurrent: () => getMouseRegistryState(registry).regions.includes(region),
+			getRect: () => {
+				try {
+					const current = region.getRect();
+					return current && isRect(current) ? current : undefined;
+				} catch {
+					return undefined;
+				}
+			},
+			dispatch: (event) => safeCall(region.onMouse, region, event),
+		};
+		const priority = typeof region.priority === "number" && Number.isFinite(region.priority) ? region.priority : 0;
+		matches.push({ target, priority, order: index });
+	}
+	matches.sort((left, right) => right.priority - left.priority || right.order - left.order);
+	return matches.map(({ target }) => target);
+}
+
+export function focusedOverlayTarget(renderer: object, x: number, y: number): MouseTarget | undefined {
+	const topmost = Reflect.get(renderer, "getTopmostVisibleOverlay") as PiPrivateValue;
+	const resolveLayout = Reflect.get(renderer, "resolveOverlayLayout") as PiPrivateValue;
+	if (typeof topmost !== "function" || typeof resolveLayout !== "function") return undefined;
+	let entry: OverlayEntry | undefined;
+	try {
+		entry = parseOverlayEntry(Reflect.apply(topmost, renderer, []) as PiPrivateValue);
+	} catch {
+		return undefined;
+	}
+	if (!entry || !mouseHandler(entry.component)) return undefined;
+
+	const getRect = (): MouseRect | undefined => {
+		const size = terminalSize(renderer);
+		if (!size) return undefined;
+		try {
+			const initial = Reflect.apply(resolveLayout, renderer, [
+				entry.options,
+				0,
+				size.columns,
+				size.rows,
+			]) as PiPrivateValue;
+			if (!isRecord(initial) || typeof initial.width !== "number") return undefined;
+			const width = Math.max(1, Math.floor(initial.width));
+			const lines = entry.component.render(width);
+			if (!Array.isArray(lines) || !lines.every((line) => typeof line === "string")) return undefined;
+			const maxHeight = typeof initial.maxHeight === "number" ? Math.max(1, Math.floor(initial.maxHeight)) : undefined;
+			const height = maxHeight === undefined ? lines.length : Math.min(lines.length, maxHeight);
+			const final = Reflect.apply(resolveLayout, renderer, [
+				entry.options,
+				height,
+				size.columns,
+				size.rows,
+			]) as PiPrivateValue;
+			if (
+				!isRecord(final) ||
+				typeof final.row !== "number" ||
+				typeof final.col !== "number" ||
+				typeof final.width !== "number"
+			) {
+				return undefined;
+			}
+			return { x: final.col, y: final.row, width: final.width, height };
+		} catch {
+			return undefined;
+		}
+	};
+	const rect = getRect();
+	if (!rect || !contains(rect, x, y)) return undefined;
+	return {
+		key: entry.component,
+		frame: rendererLayoutFrame(renderer),
+		getRect: () => rect,
+		isCurrent: () => {
+			try {
+				return parseOverlayEntry(Reflect.apply(topmost, renderer, []) as PiPrivateValue)?.component === entry.component;
+			} catch {
+				return false;
+			}
+		},
+		textInteraction: textInteractionTarget(entry.component),
+		dispatch: (event) => {
+			const handler = mouseHandler(entry.component);
+			return handler ? safeCall(handler, entry.component, event) : false;
+		},
+	};
+}
+
+export function targetsAt(
+	registry: MouseRegistry,
+	renderer: object,
+	x: number,
+	y: number,
+	includeLayout: boolean,
+	defersInputToOverlay: (renderer: object) => boolean,
+): MouseTarget[] {
+	const targets = overlayTargets(registry, x, y);
+	if (!includeLayout) return targets;
+	if (defersInputToOverlay(renderer)) {
+		const focusedOverlay = focusedOverlayTarget(renderer, x, y);
+		if (focusedOverlay) targets.push(focusedOverlay);
+		return targets;
+	}
+	const frame = rendererLayoutFrame(renderer);
+	if (frame) targets.push(...componentTargets(frame, x, y));
+	return targets;
+}

package/src/host/pi-layout-adapter.ts

@@ -0,0 +1,298 @@
+import type { Component } from "@earendil-works/pi-tui";
+import type { LayoutBox, LayoutFrame, LayoutScrollView, LayoutScrollViewReference, MouseRect } from "../mouse.ts";
+
+// type-boundary: Pi 0.84.2's private fullscreen fields are untyped; these validators narrow each reflected value.
+type PiPrivateValue = unknown;
+
+export function isRecord(value: PiPrivateValue): value is Record<PropertyKey, PiPrivateValue> {
+	return value !== null && typeof value === "object";
+}
+
+export function isRect(value: PiPrivateValue): value is MouseRect {
+	if (!isRecord(value)) return false;
+	return (
+		typeof value.x === "number" &&
+		typeof value.y === "number" &&
+		typeof value.width === "number" &&
+		typeof value.height === "number" &&
+		Number.isFinite(value.x) &&
+		Number.isFinite(value.y) &&
+		Number.isFinite(value.width) &&
+		Number.isFinite(value.height) &&
+		value.width >= 0 &&
+		value.height >= 0
+	);
+}
+
+export function isComponent(value: PiPrivateValue): value is Component {
+	if (!isRecord(value)) return false;
+	return typeof value.render === "function" && typeof value.invalidate === "function";
+}
+
+function parseLayoutScrollView(value: PiPrivateValue): LayoutScrollView | undefined {
+	if (!isRecord(value)) return undefined;
+	const scrollTop = value.scrollTop;
+	const viewportHeight = value.viewportHeight;
+	if (
+		typeof scrollTop !== "number" ||
+		!Number.isFinite(scrollTop) ||
+		typeof viewportHeight !== "number" ||
+		!Number.isFinite(viewportHeight) ||
+		viewportHeight < 0 ||
+		typeof value.scrollTo !== "function"
+	)
+		return undefined;
+	return value as unknown as LayoutScrollView;
+}
+
+export function parseLayoutScrollViewReference(value: PiPrivateValue): LayoutScrollViewReference | undefined {
+	if (!isRecord(value) || typeof value.scrollTop !== "number" || !Number.isFinite(value.scrollTop)) return undefined;
+	return value as unknown as LayoutScrollViewReference;
+}
+
+function parseLayoutBox(value: PiPrivateValue, ancestors = new Set<object>()): LayoutBox | undefined {
+	if (
+		!isRecord(value) ||
+		ancestors.has(value) ||
+		!isComponent(value.component) ||
+		!isRect(value.rect) ||
+		!isRect(value.clip) ||
+		!Array.isArray(value.children)
+	)
+		return undefined;
+	ancestors.add(value);
+	try {
+		const children: LayoutBox[] = [];
+		for (const child of value.children) {
+			const parsed = parseLayoutBox(child, ancestors);
+			if (!parsed) return undefined;
+			children.push(parsed);
+		}
+		let scrollView: LayoutScrollViewReference | undefined;
+		if (value.scrollView !== undefined) {
+			scrollView = parseLayoutScrollViewReference(value.scrollView);
+			if (!scrollView) return undefined;
+		}
+		let scrollContentLines: readonly string[] | undefined;
+		if (value.scrollContentLines !== undefined) {
+			if (
+				!Array.isArray(value.scrollContentLines) ||
+				!value.scrollContentLines.every((line) => typeof line === "string")
+			)
+				return undefined;
+			scrollContentLines = value.scrollContentLines;
+		}
+		return { component: value.component, rect: value.rect, clip: value.clip, children, scrollView, scrollContentLines };
+	} finally {
+		ancestors.delete(value);
+	}
+}
+
+function parseLayoutFrame(value: PiPrivateValue): LayoutFrame | undefined {
+	if (!isRecord(value)) return undefined;
+	const root = parseLayoutBox(value.root);
+	if (!root) return undefined;
+	let primaryScrollView: LayoutScrollView | undefined;
+	if (value.primaryScrollView !== undefined) {
+		primaryScrollView = parseLayoutScrollView(value.primaryScrollView);
+		if (!primaryScrollView) return undefined;
+	}
+	return { root, primaryScrollView };
+}
+
+const parsedLayoutFrames = new WeakMap<object, { source: object; frame: LayoutFrame | undefined }>();
+
+export function rendererLayoutFrame(renderer: object): LayoutFrame | undefined {
+	const source = Reflect.get(renderer, "currentLayout") as PiPrivateValue;
+	if (!source || typeof source !== "object") return undefined;
+	const cached = parsedLayoutFrames.get(renderer);
+	if (cached?.source === source) return cached.frame;
+	const frame = parseLayoutFrame(source);
+	parsedLayoutFrames.set(renderer, { source, frame });
+	return frame;
+}
+
+export function contains(rect: MouseRect, x: number, y: number): boolean {
+	return x >= rect.x && y >= rect.y && x < rect.x + rect.width && y < rect.y + rect.height;
+}
+
+export function intersect(left: MouseRect, right: MouseRect): MouseRect {
+	const x = Math.max(left.x, right.x);
+	const y = Math.max(left.y, right.y);
+	return {
+		x,
+		y,
+		width: Math.max(0, Math.min(left.x + left.width, right.x + right.width) - x),
+		height: Math.max(0, Math.min(left.y + left.height, right.y + right.height) - y),
+	};
+}
+
+function structuralChildren(component: Component): readonly Component[] | undefined {
+	const candidate = component as Component & {
+		children?: readonly Component[];
+		getChildren?: () => readonly Component[];
+	};
+	if (Array.isArray(candidate.children) && candidate.children.every(isComponent)) return candidate.children;
+	// Shared stacks keep their children behind a method so replacement can preserve identity.
+	if (typeof candidate.getChildren !== "function") return undefined;
+	try {
+		const children = candidate.getChildren.call(component);
+		return Array.isArray(children) && children.every(isComponent) ? children : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function hasMouseHandler(component: Component): boolean {
+	return typeof (component as Component & { onMouse?: PiPrivateValue }).onMouse === "function";
+}
+
+interface CachedStructuralSpan {
+	component: Component;
+	row: number;
+	height: number;
+	width: number;
+}
+
+function cachedStructuralSpans(component: Component): readonly CachedStructuralSpan[] | undefined {
+	const candidate = component as Component & { getSpans?: PiPrivateValue };
+	if (typeof candidate.getSpans !== "function") return undefined;
+	let value: PiPrivateValue;
+	try {
+		value = Reflect.apply(candidate.getSpans, component, []) as PiPrivateValue;
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(value)) return [];
+	const spans: CachedStructuralSpan[] = [];
+	for (const span of value) {
+		if (
+			!isRecord(span) ||
+			!isComponent(span.component) ||
+			typeof span.row !== "number" ||
+			typeof span.height !== "number" ||
+			typeof span.width !== "number" ||
+			!Number.isFinite(span.row) ||
+			!Number.isFinite(span.height) ||
+			!Number.isFinite(span.width)
+		)
+			return [];
+		spans.push({
+			component: span.component,
+			row: Math.max(0, Math.floor(span.row)),
+			height: Math.max(0, Math.floor(span.height)),
+			width: Math.max(0, Math.floor(span.width)),
+		});
+	}
+	return spans;
+}
+
+function hasMouseDescendant(component: Component, ancestors = new Set<Component>()): boolean {
+	if (ancestors.has(component)) return false;
+	const children = structuralChildren(component);
+	if (!children) return false;
+	ancestors.add(component);
+	const found = children.some((child) => hasMouseHandler(child) || hasMouseDescendant(child, ancestors));
+	ancestors.delete(component);
+	return found;
+}
+
+const derivedLayoutChildren = new WeakMap<LayoutBox, LayoutBox[]>();
+
+export function derivedChildren(box: LayoutBox): readonly LayoutBox[] {
+	if (box.children.length > 0) return box.children;
+	const existing = derivedLayoutChildren.get(box);
+	if (existing) return existing;
+	const component = isComponent(box.component) ? box.component : undefined;
+	if (!component || !hasMouseDescendant(component)) {
+		derivedLayoutChildren.set(box, []);
+		return [];
+	}
+	const cached = cachedStructuralSpans(component);
+	if (cached) {
+		const derived = cached.map((span) => {
+			const rect = {
+				x: box.rect.x,
+				y: box.rect.y + span.row,
+				width: Math.min(box.rect.width, span.width),
+				height: span.height,
+			};
+			return { component: span.component, rect, clip: intersect(box.clip, rect), children: [] };
+		});
+		derivedLayoutChildren.set(box, derived);
+		return derived;
+	}
+	const childrenToMeasure = structuralChildren(component);
+	if (!childrenToMeasure) return [];
+	const children: LayoutBox[] = [];
+	let childY = box.rect.y;
+	for (const child of childrenToMeasure) {
+		let height: number;
+		try {
+			const lines = child.render(box.rect.width);
+			if (!Array.isArray(lines) || !lines.every((line) => typeof line === "string")) return [];
+			height = lines.length;
+		} catch {
+			return [];
+		}
+		const rect = { x: box.rect.x, y: childY, width: box.rect.width, height };
+		children.push({ component: child, rect, clip: intersect(box.clip, rect), children: [] });
+		childY += height;
+	}
+	derivedLayoutChildren.set(box, children);
+	return children;
+}
+
+export function isVisibleComponent(frame: LayoutFrame, component: Component): boolean {
+	let visible = false;
+	const visit = (box: LayoutBox, ancestors: ReadonlySet<object>): void => {
+		if (visible || ancestors.has(box.component)) return;
+		if (box.component === component) {
+			const clipped = intersect(box.rect, box.clip);
+			visible = clipped.width > 0 && clipped.height > 0;
+			return;
+		}
+		const nextAncestors = new Set(ancestors);
+		nextAncestors.add(box.component);
+		for (const child of derivedChildren(box)) visit(child, nextAncestors);
+	};
+	visit(frame.root, new Set());
+	return visible;
+}
+
+export function findScrollViewBox(frame: LayoutFrame, scrollView: object): LayoutBox | undefined {
+	let result: LayoutBox | undefined;
+	const visit = (box: LayoutBox): void => {
+		if (result) return;
+		if (box.scrollView === scrollView) {
+			result = box;
+			return;
+		}
+		for (const child of box.children) visit(child);
+	};
+	visit(frame.root);
+	return result;
+}
+
+export function terminalSize(renderer: object): { rows: number; columns: number } | undefined {
+	const terminal = Reflect.get(renderer, "terminal") as PiPrivateValue;
+	if (!isRecord(terminal) || typeof terminal.rows !== "number" || typeof terminal.columns !== "number")
+		return undefined;
+	return { rows: terminal.rows, columns: terminal.columns };
+}
+
+export function rendererHasOverlay(renderer: object): boolean {
+	const method = Reflect.get(renderer, "hasOverlay") as PiPrivateValue;
+	if (typeof method !== "function") return false;
+	try {
+		return Reflect.apply(method, renderer, []) === true;
+	} catch {
+		return false;
+	}
+}
+
+export function rendererHasSelection(renderer: object): boolean {
+	return (
+		Reflect.get(renderer, "selectionAnchor") !== undefined && Reflect.get(renderer, "selectionFocus") !== undefined
+	);
+}