gentle-pi 2.4.0 → 2.6.0

package/lib/native-fullscreen-interaction.ts

@@ -0,0 +1,47 @@
+import { Container, type Component, type TuiMouseEvent } from "@earendil-works/pi-tui";
+
+export interface NativeFullscreenMouseObserver {
+	beforeMouse(event: TuiMouseEvent): void;
+	afterMouse(event: TuiMouseEvent): void;
+}
+
+export interface NativeFullscreenInteractionOptions {
+	keyboardTarget: Component;
+	requestRender(): void;
+	mouseObserver?: NativeFullscreenMouseObserver;
+}
+
+export class NativeFullscreenInteraction extends Container {
+	private readonly options: NativeFullscreenInteractionOptions;
+
+	constructor(options: NativeFullscreenInteractionOptions) {
+		super();
+		this.options = options;
+	}
+
+	handleInput(data: string): void {
+		if (!this.options.keyboardTarget.handleInput) return;
+		this.options.keyboardTarget.handleInput(data);
+		this.options.requestRender();
+	}
+
+	override handleMouse(event: TuiMouseEvent) {
+		this.options.mouseObserver?.beforeMouse(event);
+		try {
+			return super.handleMouse(event);
+		} finally {
+			this.options.mouseObserver?.afterMouse(event);
+		}
+	}
+}
+
+/**
+ * Compose native Container mouse dispatch with one keyboard-owning control.
+ * Optional observers run around native delegation without rewriting its result,
+ * so native layout, targeting, focus, wheel, and click semantics stay intact.
+ */
+export function createNativeFullscreenInteraction(
+	options: NativeFullscreenInteractionOptions,
+): NativeFullscreenInteraction {
+	return new NativeFullscreenInteraction(options);
+}

package/lib/native-pointer-region.ts

@@ -0,0 +1,164 @@
+import {
+	MouseRegion,
+	type Component,
+	type TuiMouseEvent,
+	type TuiMouseEventResult,
+} from "@earendil-works/pi-tui";
+
+export type NativePointerCallback = (event: TuiMouseEvent) => TuiMouseEventResult | undefined;
+
+export interface NativePointerRegionCallbacks {
+	onHover?: NativePointerCallback;
+	onLeave?: (event?: TuiMouseEvent) => void;
+	onPress?: NativePointerCallback;
+	onClick?: NativePointerCallback;
+	onWheel?: NativePointerCallback;
+}
+
+export interface NativePointerMouseObserver {
+	beforeMouse(event: TuiMouseEvent): void;
+	afterMouse(event: TuiMouseEvent): void;
+}
+
+/**
+ * A composable adapter around the public MouseRegion component.
+ * Child dispatch stays first, so an already handled child result is unchanged.
+ */
+export class NativePointerRegion implements Component {
+	private readonly adapter: MouseRegion;
+	private readonly callbacks: NativePointerRegionCallbacks;
+	private readonly scope: NativePointerScope | undefined;
+	private hovered = false;
+	private disabled = false;
+	private disposed = false;
+	private renderedWidth: number | undefined;
+
+	constructor(child: Component, callbacks: NativePointerRegionCallbacks, scope?: NativePointerScope) {
+		this.callbacks = callbacks;
+		this.scope = scope;
+		this.adapter = new MouseRegion(child, (event) => this.handlePointer(event));
+		this.scope?.register(this);
+	}
+
+	render(width: number): string[] {
+		if (this.renderedWidth !== undefined && this.renderedWidth !== width) this.clearHover();
+		this.renderedWidth = width;
+		return this.adapter.render(width);
+	}
+
+	handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+		if (this.disposed) return undefined;
+		return this.adapter.handleMouse(event);
+	}
+
+	invalidate(): void {
+		this.renderedWidth = undefined;
+		this.clearHover();
+		this.adapter.invalidate();
+	}
+
+	setDisabled(disabled: boolean): void {
+		if (this.disabled === disabled) return;
+		this.disabled = disabled;
+		if (disabled) this.clearHover();
+	}
+
+	clearHover(event?: TuiMouseEvent): boolean {
+		if (!this.hovered) return false;
+		this.hovered = false;
+		this.callbacks.onLeave?.(event);
+		return true;
+	}
+
+	dispose(): void {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.clearHover();
+		this.scope?.unregister(this);
+	}
+
+	private handlePointer(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+		if (this.disabled || this.disposed) return undefined;
+		if (event.type === "move" && event.button === "none") {
+			this.scope?.markMove(this, event);
+			this.hovered = true;
+			return this.callbacks.onHover?.(event);
+		}
+		if (event.type === "press") return this.callbacks.onPress?.(event);
+		if (event.type === "click") return this.callbacks.onClick?.(event);
+		if (event.type === "wheel") return this.callbacks.onWheel?.(event);
+		return undefined;
+	}
+}
+
+/** Coordinates pointer regions with a root-compatible native mouse observer. */
+export class NativePointerScope {
+	private readonly regions = new Set<NativePointerRegion>();
+	private moved = false;
+	private disabled = false;
+	private disposed = false;
+
+	wrap(child: Component, callbacks: NativePointerRegionCallbacks): NativePointerRegion {
+		const region = new NativePointerRegion(child, callbacks, this);
+		region.setDisabled(this.disabled);
+		if (this.disposed) region.dispose();
+		return region;
+	}
+
+	createMouseObserver(requestRender?: () => void): NativePointerMouseObserver {
+		return {
+			beforeMouse: (event) => {
+				if (!this.disposed && event.type === "move" && event.button === "none") this.moved = false;
+			},
+			afterMouse: (event) => {
+				if (!this.isInRoot(event) || this.moved) return;
+				if (this.clearHover(event)) requestRender?.();
+			},
+		};
+	}
+
+	setDisabled(disabled: boolean): void {
+		this.disabled = disabled;
+		for (const region of this.regions) region.setDisabled(disabled);
+	}
+
+	invalidate(): void {
+		this.clearHover();
+	}
+
+	dispose(): void {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const region of [...this.regions]) region.dispose();
+	}
+
+	register(region: NativePointerRegion): void {
+		if (!this.disposed) this.regions.add(region);
+	}
+
+	unregister(region: NativePointerRegion): void {
+		this.regions.delete(region);
+	}
+
+	markMove(region: NativePointerRegion, event: TuiMouseEvent): void {
+		this.moved = true;
+		for (const candidate of this.regions) {
+			if (candidate !== region) candidate.clearHover(event);
+		}
+	}
+
+	private clearHover(event?: TuiMouseEvent): boolean {
+		let changed = false;
+		for (const region of this.regions) changed = region.clearHover(event) || changed;
+		return changed;
+	}
+
+	private isInRoot(event: TuiMouseEvent): boolean {
+		return !this.disposed && event.type === "move" && event.button === "none" &&
+			event.x >= 0 && event.x < event.width && event.y >= 0 && event.y < event.height;
+	}
+}
+
+export function createNativePointerScope(): NativePointerScope {
+	return new NativePointerScope();
+}