@tooee/shell 0.1.9 → 0.1.12

package/src/modal.ts

@@ -1,449 +0,0 @@
-import { useState, useCallback, useRef, useEffect } from "react"
-import { useCommand, useMode, useSetMode, type Mode } from "@tooee/commands"
-import { copyToClipboard } from "@tooee/clipboard"
-import { useTerminalDimensions } from "@opentui/react"
-import { findMatchingLines } from "./search.js"
-
-export interface Position {
-  line: number
-  col: number
-}
-
-export interface ModalNavigationState {
-  mode: Mode
-  setMode: (mode: Mode) => void
-  cursor: Position | null
-  selection: { start: Position; end: Position } | null
-  toggledIndices: Set<number>
-  searchQuery: string
-  searchActive: boolean
-  setSearchQuery: (query: string) => void
-  matchingLines: number[]
-  currentMatchIndex: number
-  submitSearch: () => void
-}
-
-export interface ModalNavigationOptions {
-  totalLines: number
-  viewportHeight?: number
-  getText?: () => string | undefined
-  blockCount?: number
-  blockLineMap?: number[]
-  /** Offset to subtract from search line numbers to get block indices (for when getText has different line structure than visual) */
-  searchLineOffset?: number
-  multiSelect?: boolean
-}
-
-export function useModalNavigationCommands(opts: ModalNavigationOptions): ModalNavigationState {
-  const { height: terminalHeight } = useTerminalDimensions()
-  const {
-    totalLines,
-    viewportHeight = terminalHeight - 2,
-    getText,
-    blockCount,
-    blockLineMap,
-    searchLineOffset = 0,
-    multiSelect = false,
-  } = opts
-  const mode = useMode()
-  const setMode = useSetMode()
-
-  const [cursor, setCursor] = useState<Position | null>(null)
-  const [selectionAnchor, setSelectionAnchor] = useState<Position | null>(null)
-  const [toggledIndices, setToggledIndices] = useState<Set<number>>(new Set())
-  const [searchQuery, setSearchQuery] = useState("")
-  const [searchActive, setSearchActive] = useState(false)
-  const [matchingLines, setMatchingLines] = useState<number[]>([])
-  const [currentMatchIndex, setCurrentMatchIndex] = useState(0)
-  const preSearchModeRef = useRef<Mode>("cursor")
-
-  // Incremental search: recompute matches when query changes while search is active
-  const searchQueryRef = useRef(searchQuery)
-  searchQueryRef.current = searchQuery
-  const matchingLinesRef = useRef(matchingLines)
-  matchingLinesRef.current = matchingLines
-
-  useEffect(() => {
-    if (!searchActive) return
-    const text = getText?.()
-    if (!text || !searchQuery) {
-      setMatchingLines([])
-      setCurrentMatchIndex(0)
-      return
-    }
-    const matches = findMatchingLines(text, searchQuery)
-    setMatchingLines(matches)
-    setCurrentMatchIndex(0)
-    if (matches.length > 0) {
-      // Auto-jump to first match
-      const line = matches[0]
-      if (mode === "cursor" || mode === "select") {
-        setCursor((c) => (c ? { line, col: 0 } : c))
-      }
-    }
-  }, [searchQuery, searchActive]) // eslint-disable-line react-hooks/exhaustive-deps
-
-  const isBlockMode = blockCount != null
-  const cursorMax = isBlockMode ? Math.max(0, blockCount - 1) : Math.max(0, totalLines - 1)
-
-  const clampCursor = useCallback(
-    (value: number) => Math.max(0, Math.min(value, cursorMax)),
-    [cursorMax],
-  )
-
-  useEffect(() => {
-    setToggledIndices((prev) => {
-      const filtered = Array.from(prev).filter((index) => index <= cursorMax)
-      if (filtered.length === prev.size) return prev
-      return new Set(filtered)
-    })
-  }, [cursorMax])
-
-  // When entering cursor mode, initialize cursor if not already set
-  const prevMode = useRef<Mode | null>(null)
-  useEffect(() => {
-    if (mode === "cursor" && prevMode.current !== "cursor" && prevMode.current !== "select") {
-      setCursor((existing) => {
-        // If cursor already exists (e.g. set by a command via palette), preserve it
-        if (existing) return existing
-        // If there's an active search match, start cursor there; otherwise start at scroll position
-        const matches = matchingLinesRef.current
-        if (matches.length > 0) {
-          const matchLine = matches[currentMatchIndex] ?? matches[0]
-          // In block mode, convert search line to block index using offset
-          if (isBlockMode) {
-            const blockIndex = Math.max(0, matchLine - searchLineOffset)
-            return { line: Math.min(blockIndex, cursorMax), col: 0 }
-          }
-          return { line: matchLine, col: 0 }
-        }
-        // No search match - start at top
-        return { line: 0, col: 0 }
-      })
-    }
-    if (mode === "select" && prevMode.current === "cursor" && cursor) {
-      setSelectionAnchor({ ...cursor })
-    }
-    prevMode.current = mode
-  }, [mode]) // eslint-disable-line react-hooks/exhaustive-deps
-
-  // === CURSOR MODE ===
-
-  useCommand({
-    id: "cursor-down",
-    title: "Cursor down",
-    hotkey: "j",
-    modes: ["cursor"],
-    handler: () => {
-      setCursor((c) => {
-        if (!c) return c
-        return { line: clampCursor(c.line + 1), col: 0 }
-      })
-    },
-  })
-
-  useCommand({
-    id: "cursor-toggle",
-    title: "Toggle selection",
-    hotkey: "tab",
-    modes: ["cursor"],
-    when: () => multiSelect,
-    handler: () => {
-      setToggledIndices((prev) => {
-        if (!cursor) return prev
-        const next = new Set(prev)
-        const idx = cursor.line
-        if (next.has(idx)) {
-          next.delete(idx)
-        } else {
-          next.add(idx)
-        }
-        return next
-      })
-    },
-  })
-
-  useCommand({
-    id: "cursor-toggle-up",
-    title: "Toggle and move up",
-    hotkey: "shift+tab",
-    modes: ["cursor"],
-    when: () => multiSelect,
-    handler: () => {
-      setToggledIndices((prev) => {
-        if (!cursor) return prev
-        const next = new Set(prev)
-        const idx = cursor.line
-        if (next.has(idx)) {
-          next.delete(idx)
-        } else {
-          next.add(idx)
-        }
-        return next
-      })
-      setCursor((c) => {
-        if (!c) return c
-        return { line: clampCursor(c.line - 1), col: 0 }
-      })
-    },
-  })
-
-  useCommand({
-    id: "cursor-up",
-    title: "Cursor up",
-    hotkey: "k",
-    modes: ["cursor"],
-    handler: () => {
-      setCursor((c) => {
-        if (!c) return c
-        return { line: clampCursor(c.line - 1), col: 0 }
-      })
-    },
-  })
-
-  useCommand({
-    id: "cursor-half-down",
-    title: "Cursor half page down",
-    hotkey: "ctrl+d",
-    modes: ["cursor"],
-    handler: () => {
-      setCursor((c) => {
-        if (!c) return c
-        const step = isBlockMode ? Math.floor(cursorMax / 4) || 1 : Math.floor(viewportHeight / 2)
-        return { line: clampCursor(c.line + step), col: 0 }
-      })
-    },
-  })
-
-  useCommand({
-    id: "cursor-half-up",
-    title: "Cursor half page up",
-    hotkey: "ctrl+u",
-    modes: ["cursor"],
-    handler: () => {
-      setCursor((c) => {
-        if (!c) return c
-        const step = isBlockMode ? Math.floor(cursorMax / 4) || 1 : Math.floor(viewportHeight / 2)
-        return { line: clampCursor(c.line - step), col: 0 }
-      })
-    },
-  })
-
-  useCommand({
-    id: "cursor-top",
-    title: "Cursor to top",
-    hotkey: "g g",
-    modes: ["cursor"],
-    handler: () => {
-      setCursor({ line: 0, col: 0 })
-    },
-  })
-
-  useCommand({
-    id: "cursor-bottom",
-    title: "Cursor to bottom",
-    hotkey: "shift+g",
-    modes: ["cursor"],
-    handler: () => {
-      setCursor({ line: cursorMax, col: 0 })
-    },
-  })
-
-  useCommand({
-    id: "cursor-search-start",
-    title: "Search",
-    hotkey: "/",
-    modes: ["cursor"],
-    handler: () => {
-      preSearchModeRef.current = mode
-      setSearchActive(true)
-      setSearchQuery("")
-      setMode("insert")
-    },
-  })
-
-  useCommand({
-    id: "cursor-search-next",
-    title: "Next match",
-    hotkey: "n",
-    modes: ["cursor"],
-    when: () => !searchActive,
-    handler: () => {
-      const matches = matchingLinesRef.current
-      if (matches.length === 0) return
-      setCurrentMatchIndex((idx) => {
-        const next = (idx + 1) % matches.length
-        const line = matches[next]
-        setCursor({ line, col: 0 })
-        return next
-      })
-    },
-  })
-
-  useCommand({
-    id: "cursor-search-prev",
-    title: "Previous match",
-    hotkey: "shift+n",
-    modes: ["cursor"],
-    when: () => !searchActive,
-    handler: () => {
-      const matches = matchingLinesRef.current
-      if (matches.length === 0) return
-      setCurrentMatchIndex((idx) => {
-        const next = (idx - 1 + matches.length) % matches.length
-        const line = matches[next]
-        setCursor({ line, col: 0 })
-        return next
-      })
-    },
-  })
-
-  // === SELECT MODE ===
-
-  useCommand({
-    id: "select-down",
-    title: "Extend selection down",
-    hotkey: "j",
-    modes: ["select"],
-    handler: () => {
-      setCursor((c) => {
-        if (!c) return c
-        return { line: clampCursor(c.line + 1), col: 0 }
-      })
-    },
-  })
-
-  useCommand({
-    id: "select-up",
-    title: "Extend selection up",
-    hotkey: "k",
-    modes: ["select"],
-    handler: () => {
-      setCursor((c) => {
-        if (!c) return c
-        return { line: clampCursor(c.line - 1), col: 0 }
-      })
-    },
-  })
-
-  useCommand({
-    id: "select-toggle",
-    title: "Toggle selection",
-    hotkey: "tab",
-    modes: ["select"],
-    when: () => multiSelect,
-    handler: () => {
-      setToggledIndices((prev) => {
-        if (!cursor) return prev
-        const next = new Set(prev)
-        const idx = cursor.line
-        if (next.has(idx)) {
-          next.delete(idx)
-        } else {
-          next.add(idx)
-        }
-        return next
-      })
-    },
-  })
-
-  useCommand({
-    id: "select-copy",
-    title: "Copy selection",
-    hotkey: "y",
-    modes: ["select"],
-    handler: () => {
-      if (!getText || !selectionAnchor || !cursor) return
-      const text = getText()
-      if (!text) return
-
-      if (isBlockMode && blockLineMap) {
-        // Block-based copy: use blockLineMap to find line ranges
-        const startBlock = Math.min(selectionAnchor.line, cursor.line)
-        const endBlock = Math.max(selectionAnchor.line, cursor.line)
-        const startLine = blockLineMap[startBlock] ?? 0
-        const endLine =
-          endBlock + 1 < blockLineMap.length
-            ? (blockLineMap[endBlock + 1] ?? text.split("\n").length)
-            : text.split("\n").length
-        const lines = text.split("\n")
-        const selected = lines.slice(startLine, endLine).join("\n")
-        if (selected) {
-          void copyToClipboard(selected)
-        }
-      } else {
-        const lines = text.split("\n")
-        const startLine = Math.min(selectionAnchor.line, cursor.line)
-        const endLine = Math.max(selectionAnchor.line, cursor.line)
-        const selected = lines.slice(startLine, endLine + 1).join("\n")
-        if (selected) {
-          void copyToClipboard(selected)
-        }
-      }
-      setMode("cursor")
-    },
-  })
-
-  useCommand({
-    id: "select-cancel",
-    title: "Cancel selection",
-    hotkey: "escape",
-    modes: ["select"],
-    handler: () => setMode("cursor"),
-  })
-
-  // === MODE TRANSITIONS ===
-
-  useCommand({
-    id: "enter-select",
-    title: "Enter select mode",
-    hotkey: "v",
-    modes: ["cursor"],
-    handler: () => setMode("select"),
-  })
-
-  // === SEARCH CANCEL (any mode) ===
-
-  useCommand({
-    id: "search-cancel",
-    title: "Cancel search",
-    hotkey: "escape",
-    modes: ["cursor", "select", "insert"],
-    when: () => searchActive,
-    handler: () => {
-      setSearchActive(false)
-      setSearchQuery("")
-      setMatchingLines([])
-      setCurrentMatchIndex(0)
-      setMode(preSearchModeRef.current)
-    },
-  })
-
-  // Compute selection from anchor + cursor
-  const selection =
-    selectionAnchor && cursor && mode === "select"
-      ? {
-          start: selectionAnchor.line <= cursor.line ? selectionAnchor : cursor,
-          end: selectionAnchor.line <= cursor.line ? cursor : selectionAnchor,
-        }
-      : null
-
-  const submitSearch = useCallback(() => {
-    setSearchActive(false)
-    setMode(preSearchModeRef.current)
-  }, [setMode])
-
-  return {
-    mode,
-    setMode,
-    cursor,
-    selection,
-    toggledIndices,
-    searchQuery,
-    searchActive,
-    setSearchQuery,
-    matchingLines,
-    currentMatchIndex,
-    submitSearch,
-  }
-}