@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/terminal-selection-DBinO6p5.js

@@ -0,0 +1,330 @@
+import { shallowRef } from "vue";
+
+//#region src/selection/terminal-selection.ts
+const EMPTY_STATE = Object.freeze({
+	active: false,
+	anchor: null,
+	focus: null,
+	text: "",
+	hasRange: false
+});
+function clampPoint(point, cols, rows) {
+	return {
+		x: Math.max(0, Math.min(Math.max(0, cols - 1), Math.floor(point.x))),
+		y: Math.max(0, Math.min(Math.max(0, rows - 1), Math.floor(point.y)))
+	};
+}
+function comparePoints(a, b) {
+	return a.y - b.y || a.x - b.x;
+}
+function pointKey(point) {
+	return `${point.x}:${point.y}`;
+}
+function providerPointsDiffer(a, b) {
+	return Boolean(a && b && a.providerId === b.providerId && pointKey(a.point) !== pointKey(b.point));
+}
+function terminalSelectionRowSpans(range, cols, rows) {
+	if (cols <= 0 || rows <= 0) return [];
+	const anchor = clampPoint(range.anchor, cols, rows);
+	const focus = clampPoint(range.focus, cols, rows);
+	if (pointKey(anchor) === pointKey(focus)) return [];
+	const start = comparePoints(anchor, focus) <= 0 ? anchor : focus;
+	const end = start === anchor ? focus : anchor;
+	const spans = [];
+	for (let y = start.y; y <= end.y; y++) {
+		const x0 = y === start.y ? start.x : 0;
+		const x1 = y === end.y ? end.x + 1 : cols;
+		if (x1 > x0) spans.push({
+			y,
+			x0,
+			x1
+		});
+	}
+	return spans;
+}
+function terminalSelectionVisibleRowSpans(range, cols, rows, visibleStartY, visibleEndY) {
+	if (cols <= 0 || rows <= 0) return [];
+	const anchor = clampPoint(range.anchor, cols, rows);
+	const focus = clampPoint(range.focus, cols, rows);
+	if (pointKey(anchor) === pointKey(focus)) return [];
+	const start = comparePoints(anchor, focus) <= 0 ? anchor : focus;
+	const end = start === anchor ? focus : anchor;
+	const fromY = Math.max(start.y, Math.floor(visibleStartY), 0);
+	const toY = Math.min(end.y, Math.ceil(visibleEndY) - 1, rows - 1);
+	if (toY < fromY) return [];
+	const spans = [];
+	for (let y = fromY; y <= toY; y++) {
+		const x0 = y === start.y ? start.x : 0;
+		const x1 = y === end.y ? end.x + 1 : cols;
+		if (x1 > x0) spans.push({
+			y,
+			x0,
+			x1
+		});
+	}
+	return spans;
+}
+function selectedRowText(row, x0, x1, cols) {
+	let out = "";
+	for (let x = x0; x < x1; x++) {
+		const cell = row[x];
+		if (!cell || cell.continuation) continue;
+		out += cell.ch || " ";
+	}
+	return x1 >= cols ? out.trimEnd() : out;
+}
+function copyPayload(text, ok, error) {
+	return {
+		text,
+		rows: text ? text.split("\n").length : 0,
+		chars: text.length,
+		ok,
+		...error === void 0 ? {} : { error }
+	};
+}
+function clampPointToRect(point, rect) {
+	return {
+		x: Math.max(rect.x, Math.min(rect.x + Math.max(0, rect.w - 1), Math.floor(point.x))),
+		y: Math.max(rect.y, Math.min(rect.y + Math.max(0, rect.h - 1), Math.floor(point.y)))
+	};
+}
+function createTerminalSelectionController(options) {
+	const state = shallowRef(EMPTY_STATE);
+	let range = null;
+	let providerAnchor = null;
+	let providerFocus = null;
+	let overlaySpans = new Map();
+	let dirtyRows = new Set();
+	const readOptions = () => ({
+		autoCopy: true,
+		copyOnMouseUp: true,
+		style: { inverse: true },
+		...options.getOptions?.() ?? {}
+	});
+	const markDirty = (prev, next) => {
+		const rows = new Set();
+		for (const y of prev) rows.add(y);
+		for (const y of next) rows.add(y);
+		if (rows.size) options.onDirtyRows?.(Array.from(rows).sort((a, b) => a - b));
+	};
+	const providers = () => options.getTextProviders?.() ?? [];
+	const getRow = (y) => options.getRow?.(y) ?? options.terminal.getRow(y);
+	const providerById = (id) => providers().find((provider) => provider.id === id) ?? null;
+	const providerForCell = (point) => {
+		let best = null;
+		let bestArea = Infinity;
+		for (const provider of providers()) {
+			const rect = provider.rect;
+			if (point.x < rect.x || point.y < rect.y || point.x >= rect.x + rect.w || point.y >= rect.y + rect.h) continue;
+			const area = Math.max(0, rect.w) * Math.max(0, rect.h);
+			if (area < bestArea) {
+				best = provider;
+				bestArea = area;
+			}
+		}
+		return best;
+	};
+	const providerPointForCell = (provider, point, options$1) => {
+		const inputPoint = options$1?.clampToRect ? clampPointToRect(point, provider.rect) : point;
+		const providerPoint = provider.pointForCell?.(inputPoint) ?? inputPoint;
+		return providerPoint ? {
+			providerId: provider.id,
+			point: providerPoint
+		} : null;
+	};
+	const textFromTerminalBuffer = (nextRange) => {
+		const size = options.terminal.size();
+		const spans = terminalSelectionRowSpans(nextRange, size.cols, size.rows);
+		const lines = [];
+		for (const span of spans) lines.push(selectedRowText(getRow(span.y), span.x0, span.x1, size.cols));
+		return lines.join("\n");
+	};
+	const providerRangeFor = (provider, screenRange, anchorOverride, focusOverride) => {
+		if (anchorOverride && focusOverride && anchorOverride.providerId === provider.id && focusOverride.providerId === provider.id) return {
+			anchor: anchorOverride.point,
+			focus: focusOverride.point,
+			mode: screenRange.mode
+		};
+		const anchor = providerPointForCell(provider, screenRange.anchor, { clampToRect: true });
+		const focus = providerPointForCell(provider, screenRange.focus, { clampToRect: true });
+		if (!anchor || !focus) return null;
+		if (anchor.providerId !== provider.id || focus.providerId !== provider.id) return null;
+		return {
+			anchor: anchor.point,
+			focus: focus.point,
+			mode: screenRange.mode
+		};
+	};
+	const selectedText = () => {
+		if (!range) return "";
+		const currentRange = range;
+		if (providerAnchor && providerFocus && providerAnchor.providerId === providerFocus.providerId) {
+			const provider$1 = providerById(providerAnchor.providerId);
+			if (provider$1) {
+				const providerRange = providerRangeFor(provider$1, currentRange, providerAnchor, providerFocus);
+				if (providerRange) return provider$1.getText(providerRange);
+			}
+		}
+		const provider = providers().find((candidate) => candidate.canHandle(currentRange));
+		if (provider) {
+			const providerRange = providerRangeFor(provider, currentRange);
+			if (providerRange) return provider.getText(providerRange);
+		}
+		return textFromTerminalBuffer(currentRange);
+	};
+	const setResolvedText = (text) => {
+		if (!range || !state.value.active || state.value.text === text) return;
+		state.value = {
+			...state.value,
+			text
+		};
+	};
+	const resolveProvider = (nextRange, nextProviderAnchor) => {
+		if (!nextRange) return null;
+		if (nextProviderAnchor) {
+			const provider = providerById(nextProviderAnchor.providerId);
+			if (provider) return provider;
+		}
+		return providers().find((candidate) => candidate.canHandle(nextRange)) ?? null;
+	};
+	const rebuild = (nextRange, nextProviderAnchor, nextProviderFocus) => {
+		const previousRows = dirtyRows;
+		const size = options.terminal.size();
+		const nextOverlaySpans = new Map();
+		const nextDirtyRows = new Set();
+		let hasRange = false;
+		if (nextRange) {
+			const activeProvider = resolveProvider(nextRange, nextProviderAnchor);
+			let spans;
+			const providerRange = activeProvider != null ? providerRangeFor(activeProvider, nextRange, nextProviderAnchor, nextProviderFocus) : null;
+			if (activeProvider?.getVisibleSpans && providerRange) spans = activeProvider.getVisibleSpans(providerRange, nextRange);
+			else spans = terminalSelectionRowSpans(nextRange, size.cols, size.rows);
+			hasRange = spans.length > 0 || providerPointsDiffer(nextProviderAnchor, nextProviderFocus);
+			for (const span of spans) {
+				const x0 = Math.max(0, Math.min(size.cols, Math.floor(span.x0)));
+				const x1 = Math.max(0, Math.min(size.cols, Math.floor(span.x1)));
+				const y = Math.floor(span.y);
+				if (y < 0 || y >= size.rows || x1 <= x0) continue;
+				let list = nextOverlaySpans.get(y);
+				if (!list) {
+					list = [];
+					nextOverlaySpans.set(y, list);
+				}
+				list.push({
+					y,
+					x0,
+					x1
+				});
+				nextDirtyRows.add(y);
+			}
+		}
+		range = nextRange;
+		providerAnchor = nextProviderAnchor;
+		providerFocus = nextProviderFocus;
+		overlaySpans = nextOverlaySpans;
+		dirtyRows = nextDirtyRows;
+		state.value = nextRange ? {
+			active: true,
+			anchor: nextRange.anchor,
+			focus: nextRange.focus,
+			text: "",
+			hasRange
+		} : EMPTY_STATE;
+		markDirty(previousRows, nextDirtyRows);
+	};
+	const controller = {
+		state,
+		start(point, startOptions) {
+			const size = options.terminal.size();
+			const focus = clampPoint(point, size.cols, size.rows);
+			const anchor = startOptions?.extend && range?.anchor ? clampPoint(range.anchor, size.cols, size.rows) : focus;
+			const anchorProvider = providerForCell(anchor);
+			const focusProvider = providerForCell(focus);
+			const activeProvider = startOptions?.extend && providerAnchor ? providerById(providerAnchor.providerId) : null;
+			const nextProviderAnchor = startOptions?.extend && providerAnchor ? providerAnchor : anchorProvider ? providerPointForCell(anchorProvider, anchor) : null;
+			const nextProviderFocus = activeProvider ? providerPointForCell(activeProvider, focus, { clampToRect: true }) : nextProviderAnchor && focusProvider?.id === nextProviderAnchor.providerId ? providerPointForCell(focusProvider, focus) : null;
+			rebuild({
+				anchor,
+				focus,
+				mode: "linear"
+			}, nextProviderAnchor, nextProviderFocus);
+		},
+		update(point) {
+			if (!range) return;
+			const size = options.terminal.size();
+			const focus = clampPoint(point, size.cols, size.rows);
+			const activeProvider = providerAnchor ? providerById(providerAnchor.providerId) : null;
+			const nextProviderFocus = activeProvider ? providerPointForCell(activeProvider, focus, { clampToRect: true }) : null;
+			rebuild({
+				...range,
+				focus
+			}, providerAnchor, nextProviderFocus);
+		},
+		async finish() {
+			if (!range) return;
+			if (!state.value.hasRange) {
+				controller.clear();
+				return;
+			}
+			const current = readOptions();
+			if (!current.autoCopy || !current.copyOnMouseUp) return;
+			await controller.copy();
+		},
+		clear() {
+			if (!range && !dirtyRows.size) return;
+			rebuild(null, null, null);
+		},
+		async copy() {
+			const text = state.value.text || selectedText();
+			if (!text) return false;
+			setResolvedText(text);
+			if (!options.clipboard.supported) {
+				options.onCopy?.(copyPayload(text, false, new Error("Clipboard unavailable")));
+				return false;
+			}
+			try {
+				await options.clipboard.writeText(text);
+				options.onCopy?.(copyPayload(text, true));
+				return true;
+			} catch (error) {
+				options.onCopy?.(copyPayload(text, false, error));
+				return false;
+			}
+		},
+		paint(dirtyRowsHint) {
+			const rows = dirtyRowsHint ?? Array.from(overlaySpans.keys());
+			const selectionStyle = readOptions().style;
+			for (const y of rows) {
+				const spans = overlaySpans.get(y);
+				if (!spans?.length) continue;
+				const row = getRow(y);
+				for (const span of spans) for (let x = span.x0; x < span.x1; x++) {
+					const cell = row[x];
+					if (!cell || cell.continuation) continue;
+					const { href: _href,...baseStyle } = cell.style;
+					options.overlayTerminal.put(x, y, cell.ch || " ", {
+						...baseStyle,
+						...selectionStyle
+					});
+				}
+			}
+		},
+		refresh(refreshOptions) {
+			if (!range) return;
+			if (refreshOptions?.remapFocus) {
+				const activeProvider = providerAnchor ? providerById(providerAnchor.providerId) : resolveProvider(range, null);
+				const nextProviderFocus = activeProvider ? providerPointForCell(activeProvider, range.focus, { clampToRect: true }) : providerFocus;
+				rebuild(range, providerAnchor, nextProviderFocus);
+				return;
+			}
+			rebuild(range, providerAnchor, providerFocus);
+		},
+		clearProvider(providerId) {
+			if (providerAnchor?.providerId === providerId || providerFocus?.providerId === providerId) controller.clear();
+		}
+	};
+	return controller;
+}
+
+//#endregion
+export { createTerminalSelectionController, terminalSelectionRowSpans, terminalSelectionVisibleRowSpans };