pi-ui-extend 0.1.1

package/dist/app/mouse-controller.js

@@ -0,0 +1,968 @@
+import { copyTextToClipboard } from "./clipboard.js";
+import { stringifyUnknown } from "./message-content.js";
+import { horizontalPaddingLayout } from "./render-text.js";
+import { orderedSelection, samePoint } from "./screen-selection.js";
+import { openImageContent as openSystemImageContent } from "./image-opener.js";
+import { stringDisplayWidth } from "../terminal-width.js";
+import { formatDcpStatsToast } from "./dcp-stats.js";
+import { detectFileLinks } from "./file-links.js";
+import { openFileLink as openDetectedFileLink } from "./file-link-opener.js";
+const CLICK_FLASH_MS = 100;
+export class AppMouseController {
+    host;
+    popupMenus;
+    popupActions;
+    scrollController;
+    commandController;
+    renderedTargets = new Map();
+    renderedRowTexts = new Map();
+    renderedRowBackgrounds = new Map();
+    renderedImageTargets = new Map();
+    statusModelTarget;
+    statusThinkingTarget;
+    statusContextTarget;
+    statusModelUsageTarget;
+    statusUserJumpTarget;
+    statusThinkingExpandTarget;
+    statusCompactToolsTarget;
+    statusSessionTarget;
+    statusPromptEnhancerTarget;
+    statusVoiceMicTarget;
+    statusVoiceLanguageTarget;
+    tabLineTargets = [];
+    mouseSelection;
+    scrollBarDragActive = false;
+    inputScrollBarDragActive = false;
+    autoScrollTimer;
+    autoScrollDirection;
+    autoScrollDistance = 0;
+    autoScrollAccumulator = 0;
+    autoScrollLastTick = 0;
+    autoScrollCursorX = 1;
+    clickFlash;
+    clickFlashTimer;
+    clickFlashDirty = false;
+    renderedConversationFrame;
+    constructor(host, popupMenus, popupActions, scrollController, commandController) {
+        this.host = host;
+        this.popupMenus = popupMenus;
+        this.popupActions = popupActions;
+        this.scrollController = scrollController;
+        this.commandController = commandController;
+    }
+    handleMouse(event) {
+        if (this.handleInputScrollBar(event))
+            return;
+        if (this.handleConversationScrollBar(event))
+            return;
+        this.showClickFlashOnPress(event);
+        if (this.handleMouseSelection(event))
+            return;
+        if (this.withClickFlash(event, () => this.handleImageClick(event)))
+            return;
+        if (this.withClickFlash(event, () => this.handleFileLinkClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleTabLineClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusModelClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusThinkingClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusContextClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusModelUsageClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusUserJumpClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusThinkingExpandClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusCompactToolsClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusSessionClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusPromptEnhancerClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusVoiceMicClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusVoiceLanguageClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleExtensionInputClick(event)))
+            return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleInputClick(event)))
+            return;
+        const target = this.renderedTargets.get(event.y);
+        if (event.button === 64) {
+            if (target?.kind === "popup-menu") {
+                this.popupMenus.scrollActivePopupMenu(-3);
+                return;
+            }
+            if (this.handleInputWheel(event, -3))
+                return;
+            this.scrollController.scrollByLines(-3);
+            return;
+        }
+        if (event.button === 65) {
+            if (target?.kind === "popup-menu") {
+                this.popupMenus.scrollActivePopupMenu(3);
+                return;
+            }
+            if (this.handleInputWheel(event, 3))
+                return;
+            this.scrollController.scrollByLines(3);
+            return;
+        }
+        if (event.button !== 0)
+            return;
+        if (target?.kind === "toast") {
+            if (this.copyErrorToast(target.id)) {
+                this.showClickFlashForEvent(event);
+                return;
+            }
+            this.host.dismissToast(target.id);
+            this.showClickFlashForEvent(event);
+            return;
+        }
+        if (target?.kind === "popup-menu") {
+            const activeMenu = this.popupMenus.getActivePopupMenu(this.popupMenus.syncActivePopupMenu() ?? "slash");
+            activeMenu.selectedIndex = target.index;
+            activeMenu.moveSelection(0);
+            void this.popupActions.submitActivePopupMenu();
+            this.showClickFlashForEvent(event);
+            return;
+        }
+        if (target?.kind === "popup-menu-close") {
+            this.popupMenus.cancelActivePopupMenu();
+            this.showClickFlashForEvent(event);
+            return;
+        }
+        if (target?.kind === "todo-panel") {
+            this.host.setTodoPanelExpanded(!this.host.getTodoPanelExpanded());
+            this.showClickFlashForEvent(event);
+            return;
+        }
+        if (target?.kind === "subagents-panel") {
+            this.host.setSubagentsPanelExpanded(!this.host.getSubagentsPanelExpanded());
+            this.showClickFlashForEvent(event);
+            return;
+        }
+        if (target?.kind === "user-message") {
+            this.openUserMessageMenu(target.id);
+            this.showClickFlashForEvent(event);
+            return;
+        }
+        if (target?.kind === "queue-message") {
+            this.openQueueMessageMenu(target.id);
+            this.showClickFlashForEvent(event);
+            return;
+        }
+        if (target?.kind === "tool") {
+            const entry = this.host.findEntry(target.id);
+            if (entry?.kind === "tool" || entry?.kind === "thinking" || entry?.kind === "shell") {
+                entry.expanded = !entry.expanded;
+                this.host.touchEntry(entry);
+                this.showClickFlashForEvent(event);
+            }
+        }
+    }
+    activeClickFlash() {
+        return this.clickFlash;
+    }
+    consumeClickFlashDirty() {
+        const dirty = this.clickFlashDirty;
+        this.clickFlashDirty = false;
+        return dirty;
+    }
+    withClickFlash(event, handler) {
+        const flash = this.clickFlashForEvent(event);
+        if (!handler())
+            return false;
+        if (!event.released)
+            this.showClickFlash(flash);
+        return true;
+    }
+    showClickFlashOnPress(event) {
+        if (event.released || event.button !== 0)
+            return;
+        const region = this.clickFlashRegionForEvent(event) ?? this.inputClickFlashRegionForEvent(event);
+        if (!region)
+            return;
+        this.showClickFlash(this.clickFlashForRegion(region));
+    }
+    showClickFlashForEvent(event) {
+        if (event.released)
+            return;
+        this.showClickFlash(this.clickFlashForEvent(event));
+    }
+    showClickFlash(flash) {
+        if (this.clickFlashTimer)
+            clearTimeout(this.clickFlashTimer);
+        this.clickFlash = flash;
+        this.clickFlashDirty = true;
+        this.host.render();
+        this.clickFlashTimer = setTimeout(() => {
+            this.clickFlash = undefined;
+            this.clickFlashTimer = undefined;
+            this.clickFlashDirty = true;
+            this.host.render();
+        }, CLICK_FLASH_MS);
+    }
+    clickFlashForEvent(event) {
+        return this.clickFlashForRegion(this.clickFlashRegionForEvent(event) ?? {
+            y: event.y,
+            startColumn: event.x,
+            endColumn: event.x + 1,
+        });
+    }
+    clickFlashForRegion(region) {
+        const normalizedRegion = this.normalizedClickFlashRegion(region);
+        const background = this.renderedRowBackgrounds.get(normalizedRegion.y);
+        return {
+            ...normalizedRegion,
+            text: displayCellsInColumnRange(this.renderedRowTexts.get(normalizedRegion.y) ?? "", normalizedRegion.startColumn, normalizedRegion.endColumn),
+            ...(background === undefined ? {} : { background }),
+        };
+    }
+    clickFlashRegionForEvent(event) {
+        const imageTarget = this.imageTargetAt(event);
+        if (imageTarget)
+            return { y: event.y, startColumn: imageTarget.start + 1, endColumn: imageTarget.end + 1 };
+        const link = this.fileLinkAt(event);
+        if (link)
+            return { y: event.y, startColumn: link.start + 1, endColumn: link.end + 1 };
+        const tabTarget = this.tabLineTargetAt(event);
+        if (tabTarget)
+            return { y: tabTarget.row, startColumn: tabTarget.startColumn, endColumn: tabTarget.endColumn };
+        const statusTarget = this.statusTargetAt(event);
+        if (statusTarget)
+            return statusTarget;
+        if (this.renderedTargets.has(event.y)) {
+            const bounds = nonBlankLineBounds(this.renderedRowTexts.get(event.y) ?? "", event.x);
+            return { y: event.y, startColumn: bounds.startColumn, endColumn: bounds.endColumn };
+        }
+        return undefined;
+    }
+    normalizedClickFlashRegion(region) {
+        const columns = Math.max(1, this.host.terminalColumns());
+        const y = Math.max(1, region.y);
+        const startColumn = Math.max(1, Math.min(columns, region.startColumn));
+        const endColumn = Math.max(startColumn + 1, Math.min(columns + 1, region.endColumn));
+        return { y, startColumn, endColumn };
+    }
+    inputClickFlashRegionForEvent(event) {
+        if (!this.inputGeometry(event))
+            return undefined;
+        return { y: event.y, startColumn: event.x, endColumn: event.x + 1 };
+    }
+    imageTargetAt(event) {
+        const targets = this.renderedImageTargets.get(event.y);
+        return targets?.find((candidate) => event.x >= candidate.start + 1 && event.x <= candidate.end);
+    }
+    fileLinkAt(event) {
+        const text = this.renderedRowTexts.get(event.y);
+        if (!text)
+            return undefined;
+        return detectFileLinks(text, this.host.cwd()).find((candidate) => event.x >= candidate.start + 1 && event.x <= candidate.end);
+    }
+    statusTargetAt(event) {
+        const target = [
+            this.statusModelTarget,
+            this.statusThinkingTarget,
+            this.statusContextTarget,
+            this.statusModelUsageTarget,
+            this.statusUserJumpTarget,
+            this.statusThinkingExpandTarget,
+            this.statusCompactToolsTarget,
+            this.statusSessionTarget,
+            this.statusPromptEnhancerTarget,
+            this.statusVoiceMicTarget,
+            this.statusVoiceLanguageTarget,
+        ].find((candidate) => !!candidate
+            && event.y === candidate.row
+            && event.x >= candidate.startColumn
+            && event.x < candidate.endColumn);
+        if (!target)
+            return undefined;
+        return {
+            y: target.row,
+            startColumn: target.startColumn,
+            endColumn: target.endColumn,
+        };
+    }
+    handleImageClick(event) {
+        if (event.button !== 0 || !event.released)
+            return false;
+        const imageTarget = this.imageTargetAt(event);
+        if (!imageTarget)
+            return false;
+        const entry = this.host.findEntry(imageTarget.entryId);
+        const images = entry?.kind === "user" || entry?.kind === "tool" ? entry.images : undefined;
+        const image = images?.[imageTarget.imageIndex];
+        if (!image) {
+            this.host.showToast("Image data is not available for this message.", "warning");
+            return true;
+        }
+        const opened = this.host.openImageContent?.(image) ?? openSystemImageContent(image);
+        this.host.showToast(opened ? "Opened image." : "Could not open image with the system viewer.", opened ? "success" : "warning");
+        return true;
+    }
+    handleFileLinkClick(event) {
+        const modifiedPress = isModifiedPrimaryButton(event.button) && !event.released;
+        const plainRelease = event.button === 0 && event.released;
+        if (!modifiedPress && !plainRelease)
+            return false;
+        const link = this.fileLinkAt(event);
+        if (!link)
+            return false;
+        const opened = this.host.openFileLink?.(link) ?? openDetectedFileLink(link);
+        if (!opened)
+            this.host.showToast("Could not open file link. Install the Zed CLI or set ZED_CLI.", "warning");
+        return true;
+    }
+    handleConversationScrollBar(event) {
+        if (!this.scrollBarDragActive && this.tabLineTargetAt(event))
+            return false;
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const tabPanelRows = this.host.tabPanelRows(terminalRows);
+        const rows = editorLayoutRows(terminalRows, tabPanelRows);
+        const topOffset = editorLayoutTopOffset(tabPanelRows);
+        if (columns <= 0 || rows <= 0)
+            return false;
+        const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const localY = event.y - topOffset;
+        const insideBody = localY >= 1 && localY <= bodyHeight;
+        const onScrollBar = insideBody && event.x === columns && !!this.scrollController.scrollBarMetrics(columns, bodyHeight);
+        const baseButton = event.button & 3;
+        const draggingLeftButton = (event.button & 32) !== 0 && baseButton === 0;
+        if (event.released) {
+            if (!this.scrollBarDragActive && !onScrollBar)
+                return false;
+            this.scrollBarDragActive = false;
+            return true;
+        }
+        if (event.button === 0 && onScrollBar) {
+            this.scrollBarDragActive = true;
+            this.scrollController.scrollToScrollbarPosition(localY - 1);
+            return true;
+        }
+        if (!draggingLeftButton || !this.scrollBarDragActive)
+            return false;
+        const bodyRow = Math.max(0, Math.min(Math.max(0, bodyHeight - 1), localY - 1));
+        this.scrollController.scrollToScrollbarPosition(bodyRow);
+        return true;
+    }
+    handleInputScrollBar(event) {
+        if (!this.inputScrollBarDragActive && this.tabLineTargetAt(event))
+            return false;
+        const geometry = this.inputGeometry(event);
+        if (!geometry?.renderedInput.scrollBar)
+            return this.finishInputScrollBarDrag(event);
+        const { renderedInput, localY, inputStartRow } = geometry;
+        const scrollBar = renderedInput.scrollBar;
+        const editorRow = localY - inputStartRow - renderedInput.editorStartRowOffset;
+        const insideTrack = editorRow >= 0 && editorRow < scrollBar.trackHeight;
+        const onScrollBar = insideTrack && event.x === this.host.terminalColumns();
+        const baseButton = event.button & 3;
+        const draggingLeftButton = (event.button & 32) !== 0 && baseButton === 0;
+        if (event.released)
+            return this.finishInputScrollBarDrag(event, onScrollBar);
+        if (event.button === 0 && onScrollBar) {
+            this.inputScrollBarDragActive = true;
+            this.scrollInputToTrackRow(editorRow, scrollBar.trackHeight, renderedInput.totalLineCount, renderedInput.visibleRowCount);
+            return true;
+        }
+        if (!draggingLeftButton || !this.inputScrollBarDragActive)
+            return false;
+        const trackRow = Math.max(0, Math.min(scrollBar.trackHeight - 1, editorRow));
+        this.scrollInputToTrackRow(trackRow, scrollBar.trackHeight, renderedInput.totalLineCount, renderedInput.visibleRowCount);
+        return true;
+    }
+    finishInputScrollBarDrag(event, onScrollBar = false) {
+        if (!event.released)
+            return false;
+        if (!this.inputScrollBarDragActive && !onScrollBar)
+            return false;
+        this.inputScrollBarDragActive = false;
+        return true;
+    }
+    handleInputWheel(event, delta) {
+        const geometry = this.inputGeometry(event);
+        if (!geometry)
+            return false;
+        const { renderedInput, localY, inputStartRow, contentWidth } = geometry;
+        const inputEndRow = inputStartRow + renderedInput.lines.length;
+        const editorStartRow = inputStartRow + renderedInput.editorStartRowOffset;
+        if (localY < editorStartRow || localY >= inputEndRow)
+            return false;
+        if (this.host.inputEditor().scrollByVisualLines(delta, contentWidth, renderedInput.visibleRowCount, "", "")) {
+            this.host.render();
+        }
+        return true;
+    }
+    scrollInputToTrackRow(trackRow, trackHeight, totalLineCount, visibleRowCount) {
+        const maxScroll = Math.max(0, totalLineCount - visibleRowCount);
+        const ratio = trackHeight <= 1 ? 0 : trackRow / (trackHeight - 1);
+        const scrollOffset = Math.round(maxScroll * ratio);
+        const { contentWidth } = horizontalPaddingLayout(this.host.terminalColumns());
+        if (this.host.inputEditor().setVisualScrollOffset(scrollOffset, contentWidth, visibleRowCount, "", "")) {
+            this.host.render();
+        }
+    }
+    inputGeometry(event) {
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const tabPanelRows = this.host.tabPanelRows(terminalRows);
+        const rows = editorLayoutRows(terminalRows, tabPanelRows);
+        const localY = event.y - editorLayoutTopOffset(tabPanelRows);
+        const { renderedInput, inputStartRow } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const inputEndRow = inputStartRow + renderedInput.lines.length;
+        if (localY < inputStartRow || localY >= inputEndRow)
+            return undefined;
+        const { contentWidth } = horizontalPaddingLayout(columns);
+        return { renderedInput, inputStartRow, localY, contentWidth };
+    }
+    tabLineTargetAt(event) {
+        return this.tabLineTargets.find((candidate) => (event.y === candidate.row
+            && event.x >= candidate.startColumn
+            && event.x < candidate.endColumn));
+    }
+    handleTabLineClick(event) {
+        const target = this.tabLineTargetAt(event);
+        if (!target)
+            return false;
+        if (target.kind === "new-tab")
+            this.host.openNewTab();
+        else if (target.kind === "close")
+            this.host.closeTab(target.tabId);
+        else if (target.active)
+            void this.commandController.runResumeCommand({ preserveStatus: true, placement: "under-tabs" });
+        else
+            this.host.switchToTab(target.tabId);
+        return true;
+    }
+    handleStatusModelClick(event) {
+        const target = this.statusModelTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        this.popupMenus.openDirectPopupMenu("model");
+        this.host.render();
+        return true;
+    }
+    handleStatusThinkingClick(event) {
+        const target = this.statusThinkingTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        this.popupMenus.openDirectPopupMenu("thinking");
+        this.host.render();
+        return true;
+    }
+    handleStatusContextClick(event) {
+        const target = this.statusContextTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        const session = this.host.runtimeSession();
+        if (!session)
+            return false;
+        this.host.showToast(formatDcpStatsToast(session), "info");
+        return true;
+    }
+    handleStatusModelUsageClick(event) {
+        const target = this.statusModelUsageTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        void this.host.refreshModelUsageStatus();
+        return true;
+    }
+    handleStatusUserJumpClick(event) {
+        const target = this.statusUserJumpTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        this.popupMenus.openDirectPopupMenu("user-message-jump", { preserveStatus: true });
+        this.host.render();
+        return true;
+    }
+    handleStatusThinkingExpandClick(event) {
+        const target = this.statusThinkingExpandTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        this.host.toggleAllThinkingExpanded?.();
+        return true;
+    }
+    handleStatusCompactToolsClick(event) {
+        const target = this.statusCompactToolsTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        this.host.toggleSuperCompactTools?.();
+        return true;
+    }
+    handleStatusSessionClick(event) {
+        const target = this.statusSessionTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        void this.commandController.runResumeCommand({ preserveStatus: true });
+        return true;
+    }
+    handleStatusPromptEnhancerClick(event) {
+        const target = this.statusPromptEnhancerTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        void this.host.enhancePrompt();
+        return true;
+    }
+    handleStatusVoiceMicClick(event) {
+        const target = this.statusVoiceMicTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        this.host.toggleVoiceRecording();
+        return true;
+    }
+    handleStatusVoiceLanguageClick(event) {
+        const target = this.statusVoiceLanguageTarget;
+        if (!target)
+            return false;
+        if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
+            return false;
+        this.host.toggleVoiceLanguage();
+        return true;
+    }
+    handleInputClick(event) {
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const tabPanelRows = this.host.tabPanelRows(terminalRows);
+        const rows = editorLayoutRows(terminalRows, tabPanelRows);
+        const localY = event.y - editorLayoutTopOffset(tabPanelRows);
+        const { renderedInput, inputStartRow } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const inputEndRow = inputStartRow + renderedInput.lines.length;
+        if (localY < inputStartRow || localY >= inputEndRow)
+            return false;
+        if (localY < inputStartRow + renderedInput.editorStartRowOffset)
+            return false;
+        const visibleRowOffset = localY - inputStartRow - renderedInput.editorStartRowOffset;
+        const visualRow = renderedInput.scrollOffset + visibleRowOffset;
+        const { left, contentWidth } = horizontalPaddingLayout(columns);
+        const cursor = this.host.inputEditor().offsetAtVisualPosition(visualRow, event.x - left, contentWidth, "", "");
+        this.host.resetRequestHistoryNavigation();
+        this.host.inputEditor().setCursor(cursor, { preserveScroll: true });
+        this.host.render();
+        return true;
+    }
+    handleExtensionInputClick(event) {
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const tabPanelRows = this.host.tabPanelRows(terminalRows);
+        const rows = editorLayoutRows(terminalRows, tabPanelRows);
+        const localY = event.y - editorLayoutTopOffset(tabPanelRows);
+        const { renderedInput, inputStartRow } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const inputEndRow = inputStartRow + renderedInput.editorStartRowOffset;
+        if (localY < inputStartRow || localY >= inputEndRow)
+            return false;
+        const { left, contentWidth } = horizontalPaddingLayout(columns);
+        return this.host.handleExtensionInputMouse({
+            ...event,
+            localRow: localY - inputStartRow,
+            localColumn: event.x - left,
+            width: contentWidth,
+        });
+    }
+    openUserMessageMenu(entryId) {
+        if (!this.popupMenus.openUserMessageMenu(entryId))
+            return;
+        this.host.render();
+    }
+    openQueueMessageMenu(entryId) {
+        if (!this.popupMenus.openQueueMessageMenu(entryId))
+            return;
+        this.host.render();
+    }
+    copyErrorToast(toastId) {
+        const toast = this.host.toastEntry(toastId);
+        if (toast?.kind !== "error")
+            return false;
+        try {
+            this.copyTextToClipboard(toast.message);
+            this.host.dismissToast(toastId);
+            this.host.showToast("Error copied to clipboard", "success");
+        }
+        catch (error) {
+            this.host.showToast(`Copy failed: ${stringifyUnknown(error)}`, "error");
+        }
+        return true;
+    }
+    handleMouseSelection(event) {
+        const point = { x: event.x, y: event.y };
+        const baseButton = event.button & 3;
+        const draggingLeftButton = (event.button & 32) !== 0 && baseButton === 0;
+        if (event.released) {
+            if (!this.mouseSelection)
+                return false;
+            this.stopAutoScroll();
+            this.updateSelectionCurrentFromMouse(event, { autoScroll: false });
+            const selection = this.mouseSelection;
+            this.mouseSelection = undefined;
+            if (!selection.moved && samePoint(selection.anchor, point)) {
+                this.host.render();
+                return false;
+            }
+            const selectedText = this.getSelectedText(selection);
+            this.host.render();
+            if (selectedText.trim().length === 0)
+                return true;
+            try {
+                this.copyTextToClipboard(selectedText);
+                this.host.showToast("Copied to clipboard", "success");
+            }
+            catch (error) {
+                this.host.showToast(`Copy failed: ${stringifyUnknown(error)}`, "error");
+            }
+            return true;
+        }
+        if (draggingLeftButton) {
+            if (!this.mouseSelection)
+                return false;
+            this.updateSelectionCurrentFromMouse(event);
+            this.host.render();
+            return true;
+        }
+        if (event.button === 0) {
+            this.stopAutoScroll();
+            const conversationPoint = this.conversationPointFromMouse(event, false);
+            this.mouseSelection = conversationPoint
+                ? {
+                    anchor: conversationPoint.screen,
+                    current: conversationPoint.screen,
+                    moved: false,
+                    kind: "conversation",
+                    conversationAnchor: conversationPoint.conversation,
+                    conversationCurrent: conversationPoint.conversation,
+                }
+                : { anchor: point, current: point, moved: false, kind: "screen" };
+            return true;
+        }
+        return false;
+    }
+    syncConversationSelectionForRender(startLine, bodyHeight, topReservedRows, width) {
+        this.renderedConversationFrame = {
+            bodyHeight,
+            topRow: topReservedRows + 1,
+            viewportColumns: width,
+        };
+        const selection = this.mouseSelection;
+        if (selection?.kind !== "conversation" || !selection.conversationAnchor || !selection.conversationCurrent)
+            return;
+        const range = orderedConversationSelection(selection.conversationAnchor, selection.conversationCurrent);
+        const visibleStartLine = Math.max(range.start.line, startLine);
+        const visibleEndLine = Math.min(range.end.line, startLine + Math.max(0, bodyHeight - 1));
+        if (visibleEndLine < visibleStartLine) {
+            selection.screenAnchor = { x: 1, y: 0 };
+            selection.screenCurrent = { x: 1, y: 0 };
+            return;
+        }
+        const startX = visibleStartLine === range.start.line ? range.start.x : 1;
+        const endX = visibleEndLine === range.end.line ? range.end.x : width + 1;
+        selection.screenAnchor = {
+            x: Math.max(1, Math.min(width + 1, startX)),
+            y: topReservedRows + (visibleStartLine - startLine) + 1,
+        };
+        selection.screenCurrent = {
+            x: Math.max(1, Math.min(width + 1, endX)),
+            y: topReservedRows + (visibleEndLine - startLine) + 1,
+        };
+    }
+    updateSelectionCurrentFromMouse(event, options = {}) {
+        const selection = this.mouseSelection;
+        if (!selection)
+            return;
+        if (selection.kind === "conversation") {
+            const conversationPoint = this.conversationPointFromMouse(event, true);
+            if (!conversationPoint)
+                return;
+            selection.current = conversationPoint.screen;
+            selection.conversationCurrent = conversationPoint.conversation;
+            selection.moved = selection.moved
+                || !samePoint(selection.anchor, conversationPoint.screen)
+                || !sameConversationPoint(selection.conversationAnchor, conversationPoint.conversation);
+            if (options.autoScroll ?? true)
+                this.updateAutoScroll(event);
+            return;
+        }
+        selection.current = { x: event.x, y: event.y };
+        selection.moved = selection.moved || !samePoint(selection.anchor, selection.current);
+        this.stopAutoScroll();
+    }
+    getSelectedText(selection) {
+        if (selection.kind === "conversation" && selection.conversationAnchor && selection.conversationCurrent) {
+            return this.getSelectedConversationText(selection.conversationAnchor, selection.conversationCurrent);
+        }
+        return this.getSelectedScreenText(selection.anchor, selection.current);
+    }
+    copyTextToClipboard(text) {
+        (this.host.copyTextToClipboard ?? copyTextToClipboard)(text);
+    }
+    getSelectedScreenText(anchor, current) {
+        const range = orderedSelection(anchor, current);
+        const inputFrame = this.inputFrameCopyRows();
+        const lines = [];
+        for (let row = range.start.y; row <= range.end.y; row += 1) {
+            const text = this.renderedRowTexts.get(row) ?? "";
+            const startColumn = row === range.start.y ? range.start.x : 1;
+            const endColumn = row === range.end.y ? range.end.x : text.length + 1;
+            const selectedLine = screenSelectionLineText(row, text, startColumn, endColumn, inputFrame);
+            if (selectedLine !== undefined)
+                lines.push(selectedLine.trimEnd());
+        }
+        return lines.join("\n").replace(/\s+$/u, "");
+    }
+    inputFrameCopyRows() {
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const tabPanelRows = this.host.tabPanelRows(terminalRows);
+        const rows = editorLayoutRows(terminalRows, tabPanelRows);
+        const layout = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const topOffset = editorLayoutTopOffset(tabPanelRows);
+        const toScreenRow = (layoutRow) => Math.max(1, Math.min(terminalRows, topOffset + layoutRow));
+        const toScreenRowExclusive = (layoutRow) => Math.max(1, Math.min(terminalRows + 1, topOffset + layoutRow));
+        return {
+            inputStartRow: toScreenRow(layout.inputStartRow),
+            inputEndRow: toScreenRowExclusive(layout.inputStartRow + layout.renderedInput.lines.length),
+            inputSeparatorRow: toScreenRow(layout.inputSeparatorRow),
+            inputBottomSeparatorRow: toScreenRow(layout.inputBottomSeparatorRow),
+            contentStartColumn: 2,
+            contentEndColumn: columns,
+        };
+    }
+    getSelectedConversationText(anchor, current) {
+        const range = orderedConversationSelection(anchor, current);
+        const width = this.conversationArea()?.viewportColumns ?? this.host.terminalColumns();
+        const count = range.end.line - range.start.line + 1;
+        const renderedLines = this.host.conversationViewport().slice(width, range.start.line, count);
+        const lines = [];
+        for (let index = 0; index < count; index += 1) {
+            const text = renderedLines[index]?.text ?? "";
+            const line = range.start.line + index;
+            const startColumn = line === range.start.line ? range.start.x : 1;
+            const endColumn = line === range.end.line ? range.end.x : text.length + 1;
+            const startIndex = Math.max(0, Math.min(text.length, startColumn - 1));
+            const endIndex = Math.max(startIndex, Math.min(text.length, endColumn - 1));
+            lines.push(text.slice(startIndex, endIndex).trimEnd());
+        }
+        return lines.join("\n").replace(/\s+$/u, "");
+    }
+    conversationPointFromMouse(event, clampToViewport) {
+        const area = this.conversationArea();
+        if (!area || area.bodyHeight <= 0)
+            return undefined;
+        if (!clampToViewport && (event.y < area.topRow || event.y > area.bottomRow || event.x === this.host.terminalColumns()))
+            return undefined;
+        const screenY = Math.max(area.topRow, Math.min(area.bottomRow, event.y));
+        const screenX = Math.max(1, Math.min(area.viewportColumns + 1, event.x));
+        return {
+            conversation: {
+                line: area.metrics.start + (screenY - area.topRow),
+                x: screenX,
+            },
+            screen: { x: screenX, y: screenY },
+        };
+    }
+    conversationArea() {
+        const columns = this.host.terminalColumns();
+        const frame = this.renderedConversationFrame ?? this.computeConversationFrame(columns);
+        if (!frame)
+            return undefined;
+        const { bodyHeight, topRow } = frame;
+        if (columns <= 0 || bodyHeight <= 0)
+            return undefined;
+        const metrics = this.scrollController.scrollMetrics(columns, bodyHeight);
+        const viewportColumns = Math.max(1, Math.min(columns, frame.viewportColumns, metrics.viewportColumns));
+        return {
+            bodyHeight,
+            bottomRow: topRow + bodyHeight - 1,
+            metrics,
+            topRow,
+            viewportColumns,
+        };
+    }
+    computeConversationFrame(columns) {
+        const terminalRows = this.host.terminalRows();
+        const tabPanelRows = this.host.tabPanelRows(terminalRows);
+        const rows = editorLayoutRows(terminalRows, tabPanelRows);
+        const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        if (bodyHeight <= 0)
+            return undefined;
+        const metrics = this.scrollController.scrollMetrics(columns, bodyHeight);
+        return {
+            bodyHeight,
+            topRow: editorLayoutTopOffset(tabPanelRows) + 1,
+            viewportColumns: metrics.viewportColumns,
+        };
+    }
+    updateAutoScroll(event) {
+        const area = this.conversationArea();
+        if (!area) {
+            this.stopAutoScroll();
+            return;
+        }
+        this.autoScrollCursorX = event.x;
+        if (event.y < area.topRow) {
+            this.startAutoScroll(-1, area.topRow - event.y);
+            return;
+        }
+        if (event.y > area.bottomRow) {
+            this.startAutoScroll(1, event.y - area.bottomRow);
+            return;
+        }
+        this.stopAutoScroll();
+    }
+    startAutoScroll(direction, distance) {
+        this.autoScrollDirection = direction;
+        this.autoScrollDistance = Math.max(1, distance);
+        if (this.autoScrollTimer)
+            return;
+        this.autoScrollAccumulator = 0;
+        this.autoScrollLastTick = Date.now();
+        this.autoScrollTimer = setInterval(() => this.tickAutoScroll(), 16);
+    }
+    stopAutoScroll() {
+        if (this.autoScrollTimer)
+            clearInterval(this.autoScrollTimer);
+        this.autoScrollTimer = undefined;
+        this.autoScrollDirection = undefined;
+        this.autoScrollDistance = 0;
+        this.autoScrollAccumulator = 0;
+        this.autoScrollLastTick = 0;
+    }
+    tickAutoScroll() {
+        if (this.mouseSelection?.kind !== "conversation" || !this.autoScrollDirection) {
+            this.stopAutoScroll();
+            return;
+        }
+        const now = Date.now();
+        const elapsedSeconds = Math.max(0.001, Math.min(0.08, (now - this.autoScrollLastTick) / 1000));
+        this.autoScrollLastTick = now;
+        const linesPerSecond = Math.min(48, 8 + this.autoScrollDistance * 7);
+        this.autoScrollAccumulator += this.autoScrollDirection * linesPerSecond * elapsedSeconds;
+        const delta = Math.trunc(this.autoScrollAccumulator);
+        if (delta === 0)
+            return;
+        this.autoScrollAccumulator -= delta;
+        const scrolled = this.scrollController.scrollByLines(delta, { render: false });
+        this.updateConversationSelectionAtAutoScrollEdge();
+        if (scrolled)
+            this.host.render();
+    }
+    updateConversationSelectionAtAutoScrollEdge() {
+        const selection = this.mouseSelection;
+        if (selection?.kind !== "conversation" || !this.autoScrollDirection)
+            return;
+        const area = this.conversationArea();
+        if (!area)
+            return;
+        const screenY = this.autoScrollDirection < 0 ? area.topRow : area.bottomRow;
+        const screenX = Math.max(1, Math.min(area.viewportColumns + 1, this.autoScrollCursorX));
+        selection.current = { x: screenX, y: screenY };
+        selection.conversationCurrent = {
+            line: area.metrics.start + (screenY - area.topRow),
+            x: screenX,
+        };
+        selection.moved = true;
+    }
+}
+function orderedConversationSelection(anchor, current) {
+    if (anchor.line < current.line)
+        return { start: anchor, end: current };
+    if (anchor.line > current.line)
+        return { start: current, end: anchor };
+    return anchor.x <= current.x ? { start: anchor, end: current } : { start: current, end: anchor };
+}
+export function screenSelectionLineText(row, text, startColumn, endColumn, inputFrame) {
+    if (inputFrame && (row === inputFrame.inputSeparatorRow || row === inputFrame.inputBottomSeparatorRow)) {
+        return undefined;
+    }
+    let copyStartColumn = startColumn;
+    let copyEndColumn = endColumn;
+    if (inputFrame && row >= inputFrame.inputStartRow && row < inputFrame.inputEndRow) {
+        copyStartColumn = Math.max(copyStartColumn, inputFrame.contentStartColumn);
+        copyEndColumn = Math.min(copyEndColumn, inputFrame.contentEndColumn);
+    }
+    const startIndex = Math.max(0, Math.min(text.length, copyStartColumn - 1));
+    const endIndex = Math.max(startIndex, Math.min(text.length, copyEndColumn - 1));
+    return text.slice(startIndex, endIndex);
+}
+function sameConversationPoint(left, right) {
+    return !!left && left.line === right.line && left.x === right.x;
+}
+function displayCellsInColumnRange(text, startColumn, endColumn) {
+    let cells = "";
+    for (let column = startColumn; column < endColumn; column += 1) {
+        cells += displayCellAtColumn(text, column);
+    }
+    return cells;
+}
+function nonBlankLineBounds(text, fallbackColumn) {
+    let startColumn;
+    let endColumn;
+    let displayColumn = 1;
+    for (let index = 0; index < text.length;) {
+        const codePoint = text.codePointAt(index) ?? 0;
+        const char = String.fromCodePoint(codePoint);
+        const width = stringDisplayWidth(char);
+        index += char.length;
+        if (width <= 0)
+            continue;
+        if (/\S/u.test(char)) {
+            startColumn ??= displayColumn;
+            endColumn = displayColumn + width;
+        }
+        displayColumn += width;
+    }
+    return startColumn === undefined || endColumn === undefined
+        ? { startColumn: fallbackColumn, endColumn: fallbackColumn + 1 }
+        : { startColumn, endColumn };
+}
+function displayCellAtColumn(text, column) {
+    if (column < 1)
+        return " ";
+    let displayColumn = 1;
+    for (let index = 0; index < text.length;) {
+        const codePoint = text.codePointAt(index) ?? 0;
+        const char = String.fromCodePoint(codePoint);
+        const width = stringDisplayWidth(char);
+        index += char.length;
+        if (width <= 0)
+            continue;
+        if (column >= displayColumn && column < displayColumn + width)
+            return width === 1 ? char : " ";
+        displayColumn += width;
+    }
+    return " ";
+}
+function isModifiedPrimaryButton(button) {
+    const primaryButton = (button & 3) === 0;
+    const modifierBits = button & (8 | 16);
+    return primaryButton && modifierBits !== 0;
+}
+function editorLayoutRows(terminalRows, tabPanelRows) {
+    return Math.max(1, terminalRows - tabPanelRows);
+}
+function editorLayoutTopOffset(tabPanelRows) {
+    return tabPanelRows;
+}