opencode/packages/ui/src/pierre/selection-bridge.ts

import { type SelectedLineRange } from "@pierre/diffs"

type SelectionKey = "ui.sessionReview.selection.line" | "ui.sessionReview.selection.lines"
type SelectionVars = Record<string, string | number>

type PointerMode = "none" | "text" | "numbers"
type Side = SelectedLineRange["side"]
type LineSpan = Pick<SelectedLineRange, "start" | "end">

export function formatSelectedLineLabel(range: LineSpan, t: (key: SelectionKey, params: SelectionVars) => string) {
  const start = Math.min(range.start, range.end)
  const end = Math.max(range.start, range.end)
  if (start === end) return t("ui.sessionReview.selection.line", { line: start })
  return t("ui.sessionReview.selection.lines", { start, end })
}

export function previewSelectedLines(source: string, range: LineSpan) {
  const start = Math.max(1, Math.min(range.start, range.end))
  const end = Math.max(range.start, range.end)
  const lines = source.split("\n").slice(start - 1, end)
  if (lines.length === 0) return
  return lines.slice(0, 2).join("\n")
}

export function cloneSelectedLineRange(range: SelectedLineRange): SelectedLineRange {
  const next: SelectedLineRange = {
    start: range.start,
    end: range.end,
  }

  if (range.side) next.side = range.side
  if (range.endSide) next.endSide = range.endSide
  return next
}

export function lineInSelectedRange(range: SelectedLineRange | null | undefined, line: number, side?: Side) {
  if (!range) return false

  const start = Math.min(range.start, range.end)
  const end = Math.max(range.start, range.end)
  if (line < start || line > end) return false
  if (!side) return true

  const first = range.side
  const last = range.endSide ?? first
  if (!first && !last) return true
  if (!first || !last) return (first ?? last) === side
  if (first === last) return first === side
  if (line === start) return first === side
  if (line === end) return last === side
  return true
}

export function isSingleLineSelection(range: SelectedLineRange | null) {
  if (!range) return false
  return range.start === range.end && (range.endSide == null || range.endSide === range.side)
}

export function toRange(source: Range | StaticRange): Range {
  if (source instanceof Range) return source
  const range = new Range()
  range.setStart(source.startContainer, source.startOffset)
  range.setEnd(source.endContainer, source.endOffset)
  return range
}

export function restoreShadowTextSelection(root: ShadowRoot | undefined, range: Range | undefined) {
  if (!root || !range) return

  requestAnimationFrame(() => {
    const selection =
      (root as unknown as { getSelection?: () => Selection | null }).getSelection?.() ?? window.getSelection()
    if (!selection) return

    try {
      selection.removeAllRanges()
      selection.addRange(range)
    } catch {}
  })
}

export function createLineNumberSelectionBridge() {
  let mode: PointerMode = "none"
  let line: number | undefined
  let moved = false
  let pending = false

  const clear = () => {
    mode = "none"
    line = undefined
    moved = false
  }

  return {
    begin(numberColumn: boolean, next: number | undefined) {
      if (!numberColumn) {
        mode = "text"
        return
      }

      mode = "numbers"
      line = next
      moved = false
    },
    track(buttons: number, next: number | undefined) {
      if (mode !== "numbers") return false

      if ((buttons & 1) === 0) {
        clear()
        return true
      }

      if (next !== undefined && line !== undefined && next !== line) moved = true
      return true
    },
    finish() {
      const current = mode
      pending = current === "numbers" && moved
      clear()
      return current
    },
    consume(range: SelectedLineRange | null) {
      const result = pending && !isSingleLineSelection(range)
      pending = false
      return result
    },
    reset() {
      pending = false
      clear()
    },
  }
}