[Init] Initial commit - NetMesh terminal manager

components/terminal/runtime/middleClickBehavior.ts

@@ -0,0 +1,215 @@
+import type { MiddleClickBehavior, RightClickBehavior, TerminalSettings } from "../../../domain/models";
+
+type MiddleClickSettings = Partial<Pick<TerminalSettings, "middleClickBehavior" | "middleClickPaste">>;
+const MIDDLE_CONTEXT_MENU_EVENT_KEY = "__netcattyMiddleContextMenu";
+
+type MiddleClickContextMenuEvent = MouseEvent & {
+  [MIDDLE_CONTEXT_MENU_EVENT_KEY]?: boolean;
+};
+
+const SHIFT_SELECTION_REPLAY_EVENT_KEY = "__netcattyShiftSelectionReplay";
+
+type ShiftSelectionReplayMouseEvent = MouseEvent & {
+  [SHIFT_SELECTION_REPLAY_EVENT_KEY]?: boolean;
+};
+
+export interface MouseTrackingContextMenuCaptureState {
+  event: MouseEvent;
+  mouseTracking: boolean;
+  /** Current xterm mouse tracking mode, when available at event time. */
+  terminalMouseTrackingMode?: string;
+  status?: string | null;
+  /** The user's configured right-click action. */
+  rightClickBehavior?: RightClickBehavior;
+  /** When true, show the app context menu over fullscreen apps (tmux/vim). */
+  forceMenuInAlternateScreen?: boolean;
+}
+
+export interface ShiftMouseSelectionReplayState {
+  event: MouseEvent;
+  mouseTracking: boolean;
+  status?: string | null;
+  isMacPlatform: boolean;
+}
+
+export interface ShiftRightClickMouseDownCaptureState {
+  event: MouseEvent;
+  mouseTracking: boolean;
+  /** Current xterm mouse tracking mode, when available at event time. */
+  terminalMouseTrackingMode?: string;
+  status?: string | null;
+  /** The user's configured right-click action. */
+  rightClickBehavior?: RightClickBehavior;
+  /** When true, show the app context menu over fullscreen apps (tmux/vim). */
+  forceMenuInAlternateScreen?: boolean;
+}
+
+export const resolveMiddleClickBehavior = (
+  settings?: MiddleClickSettings | null,
+): MiddleClickBehavior => {
+  const behavior = settings?.middleClickBehavior;
+  if (
+    behavior === "context-menu" ||
+    behavior === "paste" ||
+    behavior === "disabled"
+  ) {
+    return behavior;
+  }
+
+  return settings?.middleClickPaste === false ? "disabled" : "paste";
+};
+
+export const markMiddleClickContextMenuEvent = (event: MouseEvent): MouseEvent => {
+  Object.defineProperty(event, MIDDLE_CONTEXT_MENU_EVENT_KEY, {
+    value: true,
+    configurable: true,
+  });
+  return event;
+};
+
+export const isMiddleClickContextMenuEvent = (event: MouseEvent): boolean =>
+  (event as MiddleClickContextMenuEvent)[MIDDLE_CONTEXT_MENU_EVENT_KEY] === true;
+
+export const markShiftSelectionReplayMouseEvent = (event: MouseEvent): MouseEvent => {
+  Object.defineProperty(event, SHIFT_SELECTION_REPLAY_EVENT_KEY, {
+    value: true,
+    configurable: true,
+  });
+  return event;
+};
+
+export const isShiftSelectionReplayMouseEvent = (event: MouseEvent): boolean =>
+  (event as ShiftSelectionReplayMouseEvent)[SHIFT_SELECTION_REPLAY_EVENT_KEY] === true;
+
+// When the "show context menu over fullscreen apps" setting is on and the
+// right-click action is the context menu, an unmodified right-click should
+// behave like Shift+right-click: let the contextmenu event through so Radix
+// opens the app menu, and stop the button press from reaching the TUI. Paste /
+// select-word actions are unaffected — the setting is about the menu only.
+const forcesMenuOverMouseTracking = ({
+  rightClickBehavior,
+  forceMenuInAlternateScreen,
+}: {
+  rightClickBehavior?: RightClickBehavior;
+  forceMenuInAlternateScreen?: boolean;
+}): boolean => Boolean(forceMenuInAlternateScreen && rightClickBehavior === "context-menu");
+
+export const isMouseTrackingActive = ({
+  mouseTracking,
+  terminalMouseTrackingMode,
+}: Pick<MouseTrackingContextMenuCaptureState, "mouseTracking" | "terminalMouseTrackingMode">): boolean =>
+  terminalMouseTrackingMode === undefined
+    ? mouseTracking
+    : terminalMouseTrackingMode !== "none";
+
+export const shouldInterceptMouseTrackingContextMenu = ({
+  event,
+  mouseTracking,
+  terminalMouseTrackingMode,
+  status,
+  rightClickBehavior,
+  forceMenuInAlternateScreen,
+}: MouseTrackingContextMenuCaptureState): boolean =>
+  isMouseTrackingActive({ mouseTracking, terminalMouseTrackingMode })
+  && status === "connected"
+  && !event.shiftKey
+  && !isMiddleClickContextMenuEvent(event)
+  && !forcesMenuOverMouseTracking({ rightClickBehavior, forceMenuInAlternateScreen });
+
+export const shouldReplayShiftMouseSelectionAsMacOption = ({
+  event,
+  mouseTracking,
+  status,
+  isMacPlatform,
+}: ShiftMouseSelectionReplayState): boolean =>
+  isMacPlatform
+  && mouseTracking
+  && status === "connected"
+  && event.button === 0
+  && event.shiftKey
+  && !event.altKey
+  && !event.ctrlKey
+  && !event.metaKey
+  && !isShiftSelectionReplayMouseEvent(event);
+
+export const shouldStopShiftRightClickMouseTrackingMouseDown = ({
+  event,
+  mouseTracking,
+  terminalMouseTrackingMode,
+  status,
+  rightClickBehavior,
+  forceMenuInAlternateScreen,
+}: ShiftRightClickMouseDownCaptureState): boolean =>
+  isMouseTrackingActive({ mouseTracking, terminalMouseTrackingMode })
+  && status === "connected"
+  && event.button === 2
+  && (event.shiftKey || forcesMenuOverMouseTracking({ rightClickBehavior, forceMenuInAlternateScreen }));
+
+// Pair mouseup with mousedown ownership. When Netcatty claims the press
+// (Shift / fullscreen-apps menu), also swallow the release so xterm never
+// reports a lone button-up. When the TUI owns the press (Herdr, tmux menus,
+// vim, ...), the release must reach xterm too - otherwise the app stays stuck
+// with the right button held and mouse UI dies until restart (#2721).
+// Ownership is remembered from the actual mousedown claim — never re-derived
+// from mouseup modifiers (Shift may change between press and release).
+export interface RightClickMouseTrackingPressClaim {
+  /** Evaluate + record whether this right-button mousedown was claimed. */
+  noteMouseDown: (state: ShiftRightClickMouseDownCaptureState) => boolean;
+  /** Consume the pending claim for a right-button mouseup (clears state). */
+  consumeMouseUpClaim: (event: MouseEvent) => boolean;
+}
+
+export const createRightClickMouseTrackingPressClaim = (): RightClickMouseTrackingPressClaim => {
+  let claimedMatchingMouseDown = false;
+
+  return {
+    noteMouseDown(state) {
+      const shouldStop = shouldStopShiftRightClickMouseTrackingMouseDown(state);
+      if (state.event.button === 2) {
+        claimedMatchingMouseDown = shouldStop;
+      }
+      return shouldStop;
+    },
+    consumeMouseUpClaim(event) {
+      if (event.button !== 2) return false;
+      const claimed = claimedMatchingMouseDown;
+      claimedMatchingMouseDown = false;
+      return claimed;
+    },
+  };
+};
+
+export const shouldStopRightClickMouseTrackingMouseUp = ({
+  event,
+  claimedMatchingMouseDown,
+}: {
+  event: MouseEvent;
+  claimedMatchingMouseDown: boolean;
+}): boolean => event.button === 2 && claimedMatchingMouseDown;
+
+export const createMacOptionForcedSelectionMouseEvent = (event: MouseEvent): MouseEvent =>
+  markShiftSelectionReplayMouseEvent(new MouseEvent(event.type, {
+    bubbles: event.bubbles,
+    cancelable: event.cancelable,
+    composed: event.composed,
+    detail: event.detail,
+    view: event.view,
+    screenX: event.screenX,
+    screenY: event.screenY,
+    clientX: event.clientX,
+    clientY: event.clientY,
+    ctrlKey: event.ctrlKey,
+    altKey: true,
+    shiftKey: false,
+    metaKey: event.metaKey,
+    button: event.button,
+    buttons: event.buttons,
+    relatedTarget: event.relatedTarget,
+  }));
+
+export const captureMiddleClickTerminalMouseEvent = (event: MouseEvent): boolean => {
+  if (event.button !== 1) return false;
+  event.preventDefault();
+  event.stopImmediatePropagation();
+  return true;
+};