@xincli/opentui-core 0.4.6 → 0.4.7

package/src/renderables/Select.test.ts

@@ -1,1134 +0,0 @@
-import { test, expect, beforeEach, afterEach, describe } from "bun:test"
-import { SelectRenderable, type SelectRenderableOptions, SelectRenderableEvents, type SelectOption } from "./Select.js"
-import { createTestRenderer, type MockInput, type TestRenderer } from "../testing/test-renderer.js"
-import { KeyEvent } from "../lib/KeyHandler.js"
-
-// Helper function to create a KeyEvent from a string or object
-function createKeyEvent(
-  input: string | { name: string; shift?: boolean; ctrl?: boolean; meta?: boolean; super?: boolean; baseCode?: number },
-): KeyEvent {
-  if (typeof input === "string") {
-    return new KeyEvent({
-      name: input,
-      sequence: input,
-      ctrl: false,
-      meta: false,
-      shift: false,
-      option: false,
-      number: false,
-      raw: input,
-      eventType: "press",
-      source: "raw",
-    })
-  } else {
-    return new KeyEvent({
-      name: input.name,
-      sequence: input.name === "space" ? " " : input.name,
-      ctrl: input.ctrl ?? false,
-      meta: input.meta ?? false,
-      shift: input.shift ?? false,
-      super: input.super ?? false,
-      baseCode: input.baseCode,
-      option: false,
-      number: false,
-      raw: input.name,
-      eventType: "press",
-      source: "raw",
-    })
-  }
-}
-
-let currentRenderer: TestRenderer
-let currentMockInput: MockInput
-let renderOnce: () => Promise<void>
-let captureCharFrame: () => string
-
-const sampleOptions: SelectOption[] = [
-  { name: "Option 1", description: "First option" },
-  { name: "Option 2", description: "Second option" },
-  { name: "Option 3", description: "Third option" },
-  { name: "Option 4", description: "Fourth option" },
-  { name: "Option 5", description: "Fifth option" },
-]
-
-async function createSelectRenderable(
-  renderer: TestRenderer,
-  options: SelectRenderableOptions,
-): Promise<{ select: SelectRenderable; root: any }> {
-  const selectRenderable = new SelectRenderable(renderer, { left: 0, top: 0, ...options })
-  renderer.root.add(selectRenderable)
-  await renderOnce()
-
-  return { select: selectRenderable, root: renderer.root }
-}
-
-beforeEach(async () => {
-  ;({
-    renderer: currentRenderer,
-    mockInput: currentMockInput,
-    renderOnce,
-    captureCharFrame,
-  } = await createTestRenderer({}))
-})
-
-afterEach(() => {
-  currentRenderer.destroy()
-})
-
-describe("SelectRenderable", () => {
-  describe("Initialization", () => {
-    test("should initialize with default options", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-      })
-
-      expect(select.options).toEqual(sampleOptions)
-      expect(select.getSelectedIndex()).toBe(0)
-      expect(select.getSelectedOption()).toEqual(sampleOptions[0])
-      expect(select.focusable).toBe(true)
-      expect(select.showScrollIndicator).toBe(false)
-      expect(select.showDescription).toBe(true)
-      expect(select.wrapSelection).toBe(false)
-    })
-
-    test("should initialize with custom selected index", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      expect(select.getSelectedIndex()).toBe(2)
-      expect(select.getSelectedOption()).toEqual(sampleOptions[2])
-    })
-
-    test("should scroll an initial off-screen selection into view", async () => {
-      const options: SelectOption[] = Array.from({ length: 20 }, (_, index) => ({
-        name: `Item ${index}`,
-        description: "",
-      }))
-
-      await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options,
-        selectedIndex: 12,
-        showDescription: false,
-        showScrollIndicator: true,
-      })
-
-      const frame = captureCharFrame().split("\n")
-      expect(frame.some((line) => line.includes("▶ Item 12"))).toBe(true)
-      expect(frame.findIndex((line) => line.includes("█"))).toBe(3)
-    })
-
-    test("should initialize with custom options", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        showScrollIndicator: true,
-        showDescription: false,
-        wrapSelection: true,
-        itemSpacing: 1,
-        fastScrollStep: 3,
-      })
-
-      expect(select.showScrollIndicator).toBe(true)
-      expect(select.showDescription).toBe(false)
-      expect(select.wrapSelection).toBe(true)
-    })
-
-    test("should handle empty options array", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: [],
-      })
-
-      expect(select.options).toEqual([])
-      expect(select.getSelectedIndex()).toBe(0)
-      expect(select.getSelectedOption()).toBe(null)
-    })
-
-    test("should clamp selectedIndex to valid range", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 10, // Out of range
-      })
-
-      expect(select.getSelectedIndex()).toBe(sampleOptions.length - 1)
-      expect(select.getSelectedOption()).toEqual(sampleOptions[sampleOptions.length - 1])
-    })
-  })
-
-  describe("Selection Indicator", () => {
-    test("should hide the indicator and reclaim its gutter", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        showDescription: false,
-        showSelectionIndicator: false,
-      })
-
-      expect(select.showSelectionIndicator).toBe(false)
-      expect(captureCharFrame().split("\n")[0].startsWith(" Option 1")).toBe(true)
-    })
-
-    test("should restore the default when reset", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        showDescription: false,
-        showSelectionIndicator: false,
-      })
-
-      select.showSelectionIndicator = undefined
-      await renderOnce()
-
-      expect(select.showSelectionIndicator).toBe(true)
-      expect(captureCharFrame().split("\n")[0].startsWith(" ▶ Option 1")).toBe(true)
-    })
-  })
-
-  describe("Options Management", () => {
-    test("should update options dynamically", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      const newOptions: SelectOption[] = [
-        { name: "New Option 1", description: "New first option" },
-        { name: "New Option 2", description: "New second option" },
-      ]
-
-      select.options = newOptions
-
-      expect(select.options).toEqual(newOptions)
-      expect(select.getSelectedIndex()).toBe(1) // Should be clamped to valid index
-      expect(select.getSelectedOption()).toEqual(newOptions[1])
-    })
-
-    test("should handle setting empty options", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      select.options = []
-
-      expect(select.options).toEqual([])
-      expect(select.getSelectedIndex()).toBe(0)
-      expect(select.getSelectedOption()).toBe(null)
-    })
-
-    test("should clear rendered option text when options are set to empty", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 24,
-        height: 6,
-        options: sampleOptions,
-      })
-
-      await renderOnce()
-      expect(captureCharFrame()).toContain("Option 1")
-
-      select.options = []
-      await renderOnce()
-
-      expect(captureCharFrame()).not.toContain("Option 1")
-      expect(captureCharFrame()).not.toContain("Option 2")
-    })
-
-    test("should preserve valid selected index when options change", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 1,
-      })
-
-      const extendedOptions = [...sampleOptions, { name: "Option 6", description: "Sixth option" }]
-      select.options = extendedOptions
-
-      expect(select.getSelectedIndex()).toBe(1) // Should remain the same
-      expect(select.getSelectedOption()).toEqual(sampleOptions[1])
-    })
-  })
-
-  describe("Selection Management", () => {
-    test("should set selected index programmatically", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-      })
-
-      let selectionChangedFired = false
-      let selectionIndex = -1
-      let selectionOption: SelectOption | null = null
-
-      select.on(SelectRenderableEvents.SELECTION_CHANGED, (index: number, option: SelectOption) => {
-        selectionChangedFired = true
-        selectionIndex = index
-        selectionOption = option
-      })
-
-      select.setSelectedIndex(3)
-
-      expect(select.getSelectedIndex()).toBe(3)
-      expect(select.getSelectedOption()).toEqual(sampleOptions[3])
-      expect(selectionChangedFired).toBe(true)
-      expect(selectionIndex).toBe(3)
-      expect(selectionOption!).toEqual(sampleOptions[3])
-    })
-
-    test("should ignore invalid selected index", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      const originalIndex = select.getSelectedIndex()
-      const originalOption = select.getSelectedOption()
-
-      select.setSelectedIndex(-1) // Invalid
-      expect(select.getSelectedIndex()).toBe(originalIndex)
-
-      select.setSelectedIndex(10) // Out of range
-      expect(select.getSelectedIndex()).toBe(originalIndex)
-
-      expect(select.getSelectedOption()).toEqual(originalOption)
-    })
-
-    test("should move up correctly", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      select.moveUp()
-      expect(select.getSelectedIndex()).toBe(1)
-
-      select.moveUp()
-      expect(select.getSelectedIndex()).toBe(0)
-
-      // Should not move beyond first item without wrap
-      select.moveUp()
-      expect(select.getSelectedIndex()).toBe(0)
-    })
-
-    test("should move down correctly", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      select.moveDown()
-      expect(select.getSelectedIndex()).toBe(3)
-
-      select.moveDown()
-      expect(select.getSelectedIndex()).toBe(4)
-
-      // Should not move beyond last item without wrap
-      select.moveDown()
-      expect(select.getSelectedIndex()).toBe(4)
-    })
-
-    test("should wrap selection when enabled", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        wrapSelection: true,
-      })
-
-      // Move up from first item should wrap to last
-      expect(select.getSelectedIndex()).toBe(0)
-      select.moveUp()
-      expect(select.getSelectedIndex()).toBe(4)
-
-      // Move down from last item should wrap to first
-      select.moveDown()
-      expect(select.getSelectedIndex()).toBe(0)
-    })
-
-    test("should move multiple steps", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 0,
-      })
-
-      select.moveDown(3)
-      expect(select.getSelectedIndex()).toBe(3)
-
-      select.moveUp(2)
-      expect(select.getSelectedIndex()).toBe(1)
-    })
-
-    test("should select current item", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      let itemSelectedFired = false
-      let selectedIndex = -1
-      let selectedOption: SelectOption | null = null
-
-      select.on(SelectRenderableEvents.ITEM_SELECTED, (index: number, option: SelectOption) => {
-        itemSelectedFired = true
-        selectedIndex = index
-        selectedOption = option
-      })
-
-      select.selectCurrent()
-
-      expect(itemSelectedFired).toBe(true)
-      expect(selectedIndex).toBe(2)
-      expect(selectedOption!).toEqual(sampleOptions[2])
-    })
-
-    test("should not select when no options available", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: [],
-      })
-
-      let itemSelectedFired = false
-
-      select.on(SelectRenderableEvents.ITEM_SELECTED, () => {
-        itemSelectedFired = true
-      })
-
-      select.selectCurrent()
-
-      expect(itemSelectedFired).toBe(false)
-    })
-  })
-
-  describe("Keyboard Interaction", () => {
-    test("should handle up/down arrow keys", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 1,
-      })
-
-      select.focus()
-
-      // Test down arrow
-      const downHandled = select.handleKeyPress(createKeyEvent("down"))
-      expect(downHandled).toBe(true)
-      expect(select.getSelectedIndex()).toBe(2)
-
-      // Test up arrow
-      const upHandled = select.handleKeyPress(createKeyEvent("up"))
-      expect(upHandled).toBe(true)
-      expect(select.getSelectedIndex()).toBe(1)
-    })
-
-    test("should handle j/k keys (vim-style)", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 1,
-      })
-
-      select.focus()
-
-      // Test 'j' (down)
-      const jHandled = select.handleKeyPress(createKeyEvent("j"))
-      expect(jHandled).toBe(true)
-      expect(select.getSelectedIndex()).toBe(2)
-
-      // Test 'k' (up)
-      const kHandled = select.handleKeyPress(createKeyEvent("k"))
-      expect(kHandled).toBe(true)
-      expect(select.getSelectedIndex()).toBe(1)
-    })
-
-    test("should use baseCode for custom bindings from alternate layouts", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 1,
-        keyBindings: [{ name: "j", action: "move-down" }],
-      })
-
-      select.focus()
-
-      const handled = select.handleKeyPress(createKeyEvent({ name: "ㅓ", baseCode: 106 }))
-
-      expect(handled).toBe(true)
-      expect(select.getSelectedIndex()).toBe(2)
-    })
-
-    test("should handle enter key", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      select.focus()
-
-      let itemSelectedFired = false
-      let selectedIndex = -1
-
-      select.on(SelectRenderableEvents.ITEM_SELECTED, (index: number) => {
-        itemSelectedFired = true
-        selectedIndex = index
-      })
-
-      const enterHandled = select.handleKeyPress(createKeyEvent("return"))
-      expect(enterHandled).toBe(true)
-      expect(itemSelectedFired).toBe(true)
-      expect(selectedIndex).toBe(2)
-    })
-
-    test("should handle linefeed key", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      select.focus()
-
-      let itemSelectedFired = false
-
-      select.on(SelectRenderableEvents.ITEM_SELECTED, () => {
-        itemSelectedFired = true
-      })
-
-      const linefeedHandled = select.handleKeyPress(createKeyEvent("linefeed"))
-      expect(linefeedHandled).toBe(true)
-      expect(itemSelectedFired).toBe(true)
-    })
-
-    test("should handle fast scroll with shift modifier", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 0,
-        fastScrollStep: 3,
-      })
-
-      select.focus()
-
-      // Test shift+down
-      const shiftDownHandled = select.handleKeyPress(createKeyEvent({ name: "down", shift: true }))
-      expect(shiftDownHandled).toBe(true)
-      expect(select.getSelectedIndex()).toBe(3) // Should move 3 steps
-
-      // Test shift+up
-      const shiftUpHandled = select.handleKeyPress(createKeyEvent({ name: "up", shift: true }))
-      expect(shiftUpHandled).toBe(true)
-      expect(select.getSelectedIndex()).toBe(0) // Should move back 3 steps
-    })
-
-    test("should ignore unhandled keys", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 1,
-      })
-
-      select.focus()
-
-      const originalIndex = select.getSelectedIndex()
-
-      // Test unhandled key
-      const handled = select.handleKeyPress(createKeyEvent("a"))
-      expect(handled).toBe(false)
-      expect(select.getSelectedIndex()).toBe(originalIndex)
-    })
-  })
-
-  describe("Scroll Indicator", () => {
-    const manyOptions: SelectOption[] = Array.from({ length: 20 }, (_, index) => ({
-      name: `Item ${index}`,
-      description: "",
-    }))
-
-    test.each([
-      { selectedIndex: 0, expectedRow: 1 },
-      { selectedIndex: 2, expectedRow: 1 },
-      { selectedIndex: 7, expectedRow: 2 },
-      { selectedIndex: 12, expectedRow: 3 },
-      { selectedIndex: 17, expectedRow: 4 },
-      { selectedIndex: 19, expectedRow: 4 },
-    ])("renders the viewport position for selected index $selectedIndex", async ({ selectedIndex, expectedRow }) => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: manyOptions,
-        showScrollIndicator: true,
-        showDescription: false,
-      })
-
-      select.setSelectedIndex(selectedIndex)
-      await renderOnce()
-
-      const indicatorRow = captureCharFrame()
-        .split("\n")
-        .findIndex((line) => line.includes("█"))
-      expect(indicatorRow).toBe(expectedRow)
-    })
-  })
-
-  describe("Property Changes", () => {
-    test("should update showScrollIndicator", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        showScrollIndicator: false,
-      })
-
-      expect(select.showScrollIndicator).toBe(false)
-
-      select.showScrollIndicator = true
-      expect(select.showScrollIndicator).toBe(true)
-    })
-
-    test("should update showDescription", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        showDescription: true,
-      })
-
-      expect(select.showDescription).toBe(true)
-
-      select.showDescription = false
-      expect(select.showDescription).toBe(false)
-    })
-
-    test("should update wrapSelection", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        wrapSelection: false,
-      })
-
-      expect(select.wrapSelection).toBe(false)
-
-      select.wrapSelection = true
-      expect(select.wrapSelection).toBe(true)
-    })
-
-    test("should update colors", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-      })
-
-      // Test all color setters
-      select.backgroundColor = "#ff0000"
-      select.textColor = "#00ff00"
-      select.focusedBackgroundColor = "#0000ff"
-      select.focusedTextColor = "#ffff00"
-      select.selectedBackgroundColor = "#ff00ff"
-      select.selectedTextColor = "#00ffff"
-      select.descriptionColor = "#808080"
-      select.selectedDescriptionColor = "#ffffff"
-
-      // Should not throw errors
-      expect(select).toBeDefined()
-    })
-
-    test("should update font", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-      })
-
-      select.font = "tiny"
-      // Should not throw errors
-      expect(select).toBeDefined()
-    })
-
-    test("should update itemSpacing", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        itemSpacing: 0,
-      })
-
-      select.itemSpacing = 2
-      // Should not throw errors
-      expect(select).toBeDefined()
-    })
-
-    test("should update fastScrollStep", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        fastScrollStep: 5,
-      })
-
-      select.fastScrollStep = 10
-      // Should not throw errors
-      expect(select).toBeDefined()
-    })
-
-    test("should update selectedIndex via setter", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 0,
-      })
-
-      select.selectedIndex = 3
-      expect(select.getSelectedIndex()).toBe(3)
-    })
-  })
-
-  describe("Event Emission", () => {
-    test("should emit SELECTION_CHANGED when moving", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 1,
-      })
-
-      let eventCount = 0
-      let lastIndex = -1
-      let lastOption: SelectOption | null = null
-
-      select.on(SelectRenderableEvents.SELECTION_CHANGED, (index: number, option: SelectOption) => {
-        eventCount++
-        lastIndex = index
-        lastOption = option
-      })
-
-      select.moveDown()
-      expect(eventCount).toBe(1)
-      expect(lastIndex).toBe(2)
-      expect(lastOption!).toEqual(sampleOptions[2])
-
-      select.moveUp()
-      expect(eventCount).toBe(2)
-      expect(lastIndex).toBe(1)
-      expect(lastOption!).toEqual(sampleOptions[1])
-    })
-
-    test("should emit ITEM_SELECTED when selecting", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 2,
-      })
-
-      let eventCount = 0
-      let lastIndex = -1
-      let lastOption: SelectOption | null = null
-
-      select.on(SelectRenderableEvents.ITEM_SELECTED, (index: number, option: SelectOption) => {
-        eventCount++
-        lastIndex = index
-        lastOption = option
-      })
-
-      select.selectCurrent()
-      expect(eventCount).toBe(1)
-      expect(lastIndex).toBe(2)
-      expect(lastOption!).toEqual(sampleOptions[2])
-    })
-
-    test("should not reuse the same keypress after focusing another select", async () => {
-      const { select: first } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 1,
-      })
-      const { select: second } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: [
-          { name: "A", description: "A" },
-          { name: "B", description: "B" },
-        ],
-      })
-
-      let firstSelections = 0
-      let secondSelections = 0
-
-      first.on(SelectRenderableEvents.ITEM_SELECTED, () => {
-        firstSelections++
-        second.focus()
-      })
-      second.on(SelectRenderableEvents.ITEM_SELECTED, () => {
-        secondSelections++
-      })
-
-      first.focus()
-      currentMockInput.pressKey("RETURN")
-
-      expect(firstSelections).toBe(1)
-      expect(secondSelections).toBe(0)
-      expect(second.focused).toBe(true)
-    })
-
-    test("should emit events even when movement is blocked", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-        selectedIndex: 0, // At the beginning
-        wrapSelection: false,
-      })
-
-      let eventCount = 0
-
-      select.on(SelectRenderableEvents.SELECTION_CHANGED, () => {
-        eventCount++
-      })
-
-      // Try to move up from first item (index stays the same but event is emitted)
-      select.moveUp()
-      expect(eventCount).toBe(1)
-      expect(select.getSelectedIndex()).toBe(0)
-
-      // Try to move down to last item and then try to move down again
-      select.setSelectedIndex(4) // Move to last item
-      eventCount = 0 // Reset counter
-
-      select.moveDown()
-      expect(eventCount).toBe(1)
-      expect(select.getSelectedIndex()).toBe(4) // Should stay at last item
-    })
-  })
-
-  describe("Resize Handling", () => {
-    test("should handle resize events", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-      })
-
-      // Simulate resize by calling onResize directly
-      // @ts-expect-error - Testing protected method
-      select.onResize(30, 10)
-
-      // Should not throw errors and should be able to continue functioning
-      expect(select.getSelectedIndex()).toBe(0)
-      expect(select.getSelectedOption()).toEqual(sampleOptions[0])
-    })
-  })
-
-  describe("Edge Cases", () => {
-    test("should handle options with undefined values", async () => {
-      const optionsWithValues: SelectOption[] = [
-        { name: "Option 1", description: "First option", value: "value1" },
-        { name: "Option 2", description: "Second option", value: undefined },
-        { name: "Option 3", description: "Third option" },
-      ]
-
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: optionsWithValues,
-      })
-
-      expect(select.options).toEqual(optionsWithValues)
-      expect(select.getSelectedOption()?.value).toBe("value1")
-
-      select.setSelectedIndex(1)
-      expect(select.getSelectedOption()?.value).toBe(undefined)
-
-      select.setSelectedIndex(2)
-      expect(select.getSelectedOption()?.value).toBe(undefined)
-    })
-
-    test("should handle single option", async () => {
-      const singleOption: SelectOption[] = [{ name: "Only Option", description: "The only choice" }]
-
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: singleOption,
-      })
-
-      expect(select.getSelectedIndex()).toBe(0)
-      expect(select.getSelectedOption()).toEqual(singleOption[0])
-
-      let eventCount = 0
-      select.on(SelectRenderableEvents.SELECTION_CHANGED, () => {
-        eventCount++
-      })
-
-      // Movement should not change selection but events are still emitted
-      select.moveUp()
-      expect(select.getSelectedIndex()).toBe(0)
-      expect(eventCount).toBe(1)
-
-      select.moveDown()
-      expect(select.getSelectedIndex()).toBe(0)
-      expect(eventCount).toBe(2)
-    })
-
-    test("should handle very small dimensions", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 1,
-        height: 1,
-        options: sampleOptions,
-      })
-
-      // Should still function even with minimal space
-      expect(select.getSelectedIndex()).toBe(0)
-      expect(select.getSelectedOption()).toEqual(sampleOptions[0])
-
-      select.moveDown()
-      expect(select.getSelectedIndex()).toBe(1)
-    })
-
-    test("should handle long option names and descriptions", async () => {
-      const longOptions: SelectOption[] = [
-        {
-          name: "This is a very long option name that exceeds normal width",
-          description:
-            "This is an extremely long description that definitely exceeds the available width and should be handled gracefully",
-        },
-        {
-          name: "Short",
-          description: "Short desc",
-        },
-      ]
-
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 10,
-        height: 5,
-        options: longOptions,
-      })
-
-      expect(select.getSelectedIndex()).toBe(0)
-      expect(select.getSelectedOption()).toEqual(longOptions[0])
-
-      select.moveDown()
-      expect(select.getSelectedIndex()).toBe(1)
-      expect(select.getSelectedOption()).toEqual(longOptions[1])
-    })
-
-    test("should handle focus state changes", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 5,
-        options: sampleOptions,
-      })
-
-      expect(select.focused).toBe(false)
-
-      select.focus()
-      expect(select.focused).toBe(true)
-
-      select.blur()
-      expect(select.focused).toBe(false)
-    })
-  })
-
-  describe("Key Bindings and Aliases", () => {
-    test("should support custom key bindings", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 10,
-        options: sampleOptions,
-        keyBindings: [
-          { name: "h", action: "move-up" },
-          { name: "l", action: "move-down" },
-        ],
-      })
-
-      select.focus()
-      expect(select.getSelectedIndex()).toBe(0)
-
-      // H should move up (but we're at top)
-      currentMockInput.pressKey("h")
-      expect(select.getSelectedIndex()).toBe(0)
-
-      // L should move down
-      currentMockInput.pressKey("l")
-      expect(select.getSelectedIndex()).toBe(1)
-    })
-
-    test("should support key aliases", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 10,
-        options: sampleOptions,
-        keyAliasMap: {
-          enter: "return",
-        },
-      })
-
-      select.focus()
-      select.setSelectedIndex(1)
-
-      let itemSelected = false
-      select.on(SelectRenderableEvents.ITEM_SELECTED, () => {
-        itemSelected = true
-      })
-
-      currentMockInput.pressEnter()
-      expect(itemSelected).toBe(true)
-    })
-
-    test("should merge custom bindings with defaults", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 10,
-        options: sampleOptions,
-        keyBindings: [{ name: "n", action: "move-down" }],
-      })
-
-      select.focus()
-      expect(select.getSelectedIndex()).toBe(0)
-
-      // Default binding should still work
-      currentMockInput.pressArrow("down")
-      expect(select.getSelectedIndex()).toBe(1)
-
-      // Custom binding should also work
-      currentMockInput.pressKey("n")
-      expect(select.getSelectedIndex()).toBe(2)
-    })
-
-    test("should override default bindings with custom ones", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 10,
-        options: sampleOptions,
-        keyBindings: [
-          { name: "k", action: "move-down" }, // Override k to move down instead of up
-        ],
-      })
-
-      select.focus()
-      expect(select.getSelectedIndex()).toBe(0)
-
-      // K should now move down instead of up
-      currentMockInput.pressKey("k")
-      expect(select.getSelectedIndex()).toBe(1)
-    })
-
-    test("should support fast scroll with shift by default", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 10,
-        options: sampleOptions,
-        fastScrollStep: 3,
-      })
-
-      select.focus()
-      expect(select.getSelectedIndex()).toBe(0)
-
-      // Shift+Down should fast scroll
-      currentMockInput.pressArrow("down", { shift: true })
-      expect(select.getSelectedIndex()).toBe(3)
-    })
-
-    test("should allow custom bindings for fast scroll", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 10,
-        options: sampleOptions,
-        fastScrollStep: 2,
-        keyBindings: [{ name: "down", ctrl: true, action: "move-down-fast" }],
-      })
-
-      select.focus()
-      expect(select.getSelectedIndex()).toBe(0)
-
-      // Ctrl+Down should fast scroll down
-      currentMockInput.pressArrow("down", { ctrl: true })
-      expect(select.getSelectedIndex()).toBe(2)
-    })
-
-    test("should allow updating key bindings dynamically", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 10,
-        options: sampleOptions,
-      })
-
-      select.focus()
-      expect(select.getSelectedIndex()).toBe(0)
-
-      // Move down with default binding
-      currentMockInput.pressArrow("down")
-      expect(select.getSelectedIndex()).toBe(1)
-
-      // Update bindings
-      select.keyBindings = [{ name: "x", action: "move-down" }]
-
-      // X should now move down
-      currentMockInput.pressKey("x")
-      expect(select.getSelectedIndex()).toBe(2)
-    })
-
-    test("should handle modifiers in custom bindings", async () => {
-      const { select } = await createSelectRenderable(currentRenderer, {
-        width: 20,
-        height: 10,
-        options: sampleOptions,
-        keyBindings: [
-          { name: "n", ctrl: true, action: "move-down" },
-          { name: "p", ctrl: true, action: "move-up" },
-        ],
-      })
-
-      select.focus()
-      select.setSelectedIndex(2)
-
-      // Ctrl+P should move up
-      currentMockInput.pressKey("p", { ctrl: true })
-      expect(select.getSelectedIndex()).toBe(1)
-
-      // Ctrl+N should move down
-      currentMockInput.pressKey("n", { ctrl: true })
-      expect(select.getSelectedIndex()).toBe(2)
-    })
-  })
-})