@luan.sh/pi-libtui 0.3.8

package/src/host/pi-native-selection.ts

@@ -0,0 +1,227 @@
+import { sliceByColumn, stripTerminalSequences, visibleWidth } from "@earendil-works/pi-tui";
+import type {
+	FullscreenLayout,
+	FullscreenLayoutCapability,
+	LayoutFrame,
+	LayoutScrollViewReference,
+	LayoutSelectionPoint,
+} from "../mouse.ts";
+import type { NativeSelectionCompleted, NativeSelectionGeometry, SelectionPoint } from "../selection.ts";
+import {
+	findScrollViewBox,
+	intersect,
+	isRecord,
+	parseLayoutScrollViewReference,
+	rendererLayoutFrame,
+	terminalSize,
+} from "./pi-layout-adapter.ts";
+
+interface PrivateSelectionPoint extends SelectionPoint {
+	scrollView?: LayoutScrollViewReference;
+	boundary?: boolean;
+}
+
+// type-boundary: Pi 0.84.2's private selection fields are untyped; these validators narrow each reflected value.
+type PiPrivateValue = unknown;
+
+function parseSelectionPoint(value: PiPrivateValue): PrivateSelectionPoint | undefined {
+	if (!isRecord(value) || typeof value.row !== "number" || typeof value.col !== "number") return undefined;
+	if (!Number.isFinite(value.row) || !Number.isFinite(value.col)) return undefined;
+	const scrollView = value.scrollView === undefined ? undefined : parseLayoutScrollViewReference(value.scrollView);
+	if (value.scrollView !== undefined && !scrollView) return undefined;
+	return {
+		row: value.row,
+		col: value.col,
+		scrollView,
+		boundary: value.boundary === true,
+	};
+}
+
+function clamp(value: number, minimum: number, maximum: number): number {
+	return Math.max(minimum, Math.min(maximum, value));
+}
+
+function selectionScreenPoint(
+	point: PrivateSelectionPoint,
+	frame: LayoutFrame,
+	size: { rows: number; columns: number },
+): SelectionPoint | undefined {
+	if (!point.scrollView) {
+		return {
+			row: clamp(point.row, 0, Math.max(0, size.rows - 1)),
+			col: clamp(point.col, 0, Math.max(0, size.columns - 1)),
+		};
+	}
+	const box = findScrollViewBox(frame, point.scrollView);
+	if (!box || box.rect.width <= 0 || box.rect.height <= 0) return undefined;
+	const scrollTop = Reflect.get(point.scrollView, "scrollTop") as PiPrivateValue;
+	if (typeof scrollTop !== "number") return undefined;
+	const visible = intersect(box.rect, box.clip);
+	if (visible.width <= 0 || visible.height <= 0) return undefined;
+	const rawRow = box.rect.y + point.row - scrollTop;
+	const row = clamp(rawRow, visible.y, visible.y + visible.height - 1);
+	const rawCol =
+		rawRow < visible.y
+			? visible.x
+			: rawRow >= visible.y + visible.height
+				? visible.x + visible.width - 1
+				: box.rect.x + point.col;
+	return {
+		row: clamp(row, 0, Math.max(0, size.rows - 1)),
+		col: clamp(rawCol, visible.x, Math.min(size.columns - 1, visible.x + visible.width - 1)),
+	};
+}
+
+function selectionLines(
+	renderer: object,
+	frame: LayoutFrame,
+	start: PrivateSelectionPoint,
+): readonly string[] | undefined {
+	if (start.scrollView) {
+		return findScrollViewBox(frame, start.scrollView)?.scrollContentLines;
+	}
+	const previousScreen = Reflect.get(renderer, "previousScreen") as PiPrivateValue;
+	return Array.isArray(previousScreen) && previousScreen.every((line) => typeof line === "string")
+		? previousScreen
+		: undefined;
+}
+
+function selectedText(lines: readonly string[], start: PrivateSelectionPoint, end: PrivateSelectionPoint): string {
+	const selected: string[] = [];
+	for (let row = start.row; row <= end.row; row += 1) {
+		const source = lines[row] ?? "";
+		const width = visibleWidth(source);
+		const from = row === start.row ? Math.min(start.col, width) : 0;
+		const to = row === end.row ? Math.min(end.boundary ? end.col : end.col + 1, width) : width;
+		selected.push(stripTerminalSequences(sliceByColumn(source, from, Math.max(0, to - from), true)).trimEnd());
+	}
+	return selected.join("\n");
+}
+
+const SELECTION_QUOTE_CONTEXT = 80;
+
+function selectionQuote(
+	lines: readonly string[],
+	start: PrivateSelectionPoint,
+	exact: string,
+): { exact: string; prefix?: string; suffix?: string } {
+	const plainLines = lines.map((line) => stripTerminalSequences(line).trimEnd());
+	if (!Number.isInteger(start.row) || start.row < 0 || start.row >= plainLines.length) return { exact };
+	let offset = 0;
+	for (let row = 0; row < start.row; row += 1) offset += plainLines[row]!.length + 1;
+	const sourceLine = lines[start.row] ?? "";
+	const prefix = stripTerminalSequences(sliceByColumn(sourceLine, 0, Math.max(0, start.col), true));
+	offset += Math.min(prefix.length, plainLines[start.row]!.length);
+	const source = plainLines.join("\n");
+	if (source.slice(offset, offset + exact.length) !== exact) return { exact };
+	return {
+		exact,
+		...(offset > 0 ? { prefix: source.slice(Math.max(0, offset - SELECTION_QUOTE_CONTEXT), offset) } : {}),
+		...(offset + exact.length < source.length
+			? { suffix: source.slice(offset + exact.length, offset + exact.length + SELECTION_QUOTE_CONTEXT) }
+			: {}),
+	};
+}
+
+interface NativeSelectionSnapshot {
+	start: PrivateSelectionPoint;
+	end: PrivateSelectionPoint;
+	frame: LayoutFrame;
+	geometry: NativeSelectionGeometry;
+}
+
+function nativeSelectionSnapshot(renderer: object): NativeSelectionSnapshot | undefined {
+	const anchor = parseSelectionPoint(Reflect.get(renderer, "selectionAnchor") as PiPrivateValue);
+	const focus = parseSelectionPoint(Reflect.get(renderer, "selectionFocus") as PiPrivateValue);
+	if (!anchor || !focus || anchor.scrollView !== focus.scrollView) return undefined;
+	if (anchor.row === focus.row && anchor.col === focus.col) return undefined;
+	const anchorFirst = anchor.row < focus.row || (anchor.row === focus.row && anchor.col < focus.col);
+	const start = anchorFirst ? anchor : focus;
+	const end = anchorFirst ? focus : anchor;
+	const frame = rendererLayoutFrame(renderer);
+	const size = terminalSize(renderer);
+	if (!frame || !size) return undefined;
+	const screenStart = selectionScreenPoint(start, frame, size);
+	const screenEnd = selectionScreenPoint(end, frame, size);
+	if (!screenStart || !screenEnd) return undefined;
+	return {
+		start,
+		end,
+		frame,
+		geometry: {
+			shape: Reflect.get(renderer, "selectionGranularity") === "line" ? "line" : "character",
+			logical: {
+				start: { row: start.row, col: start.col },
+				end: { row: end.row, col: end.col },
+			},
+			screen: { start: screenStart, end: screenEnd },
+		},
+	};
+}
+
+export function nativeSelectionGeometry(renderer: object): NativeSelectionGeometry | undefined {
+	return nativeSelectionSnapshot(renderer)?.geometry;
+}
+
+export function nativeSelectionCompleted(renderer: object): NativeSelectionCompleted | undefined {
+	const snapshot = nativeSelectionSnapshot(renderer);
+	if (!snapshot) return undefined;
+	const { start, end, frame, geometry } = snapshot;
+	const lines = selectionLines(renderer, frame, start);
+	if (!lines) return undefined;
+	const text = selectedText(lines, start, end);
+	return { ...geometry, text, source: { quote: selectionQuote(lines, start, text) } };
+}
+
+export function rendererFullscreenLayout(renderer: object): FullscreenLayout | undefined {
+	const frame = rendererLayoutFrame(renderer);
+	const primaryScrollView = frame?.primaryScrollView;
+	if (!frame || !primaryScrollView) return undefined;
+	const primaryBox = findScrollViewBox(frame, primaryScrollView);
+	const lines = primaryBox?.scrollContentLines;
+	const viewport = primaryBox ? intersect(primaryBox.rect, primaryBox.clip) : undefined;
+	if (!primaryBox || !lines || !viewport || viewport.width <= 0 || viewport.height <= 0) return undefined;
+	const selectionPoint = (key: "selectionAnchor" | "selectionFocus"): LayoutSelectionPoint | undefined => {
+		const point = parseSelectionPoint(Reflect.get(renderer, key) as PiPrivateValue);
+		if (point?.scrollView !== primaryScrollView) return undefined;
+		return {
+			row: point.row,
+			col: point.col,
+			scrollView: primaryScrollView,
+			...(point.boundary ? { boundary: true } : {}),
+		};
+	};
+	return {
+		frame,
+		primaryBox,
+		primaryScrollView,
+		lines,
+		viewport: { ...viewport, scrollTop: primaryScrollView.scrollTop },
+		get selectionAnchor() {
+			return selectionPoint("selectionAnchor");
+		},
+		get selectionFocus() {
+			return selectionPoint("selectionFocus");
+		},
+		setSelection(anchor, focus) {
+			Reflect.set(renderer, "selectionAnchor", anchor);
+			Reflect.set(renderer, "selectionFocus", focus);
+			Reflect.set(renderer, "selectionActive", anchor !== undefined && focus !== undefined);
+		},
+		point(point, boundary = false) {
+			return { ...point, scrollView: primaryScrollView, ...(boundary ? { boundary: true } : {}) };
+		},
+		screenPoint(point) {
+			return {
+				row: primaryBox.rect.y + point.row - primaryScrollView.scrollTop,
+				col: primaryBox.rect.x + point.col,
+			};
+		},
+	};
+}
+
+export const fullscreenLayoutCapability: FullscreenLayoutCapability = {
+	protocol: "pi-libtui/fullscreen-layout/v1",
+	version: 1,
+	resolve: rendererFullscreenLayout,
+};