gravity list sorta

[wolfercarter-cpu]

`from future import annotations
from textual.app import ComposeResult
from textual.widget import Widget
from textual.widgets import Input, OptionList
from textual.containers import Vertical
from textual.events import Key
from rich.console import RenderableType

class GravityList(Widget):
"""A standalone gravity list widget with Tab-switching and auto-snapping focus."""

def __init__(
    self,
    placeholder: str = "Search...",
    id: str | None = None,
    classes: str | None = None,
) -> None:
    super().__init__(id=id, classes=classes)
    self.placeholder = placeholder
    self._items: list[tuple[str, RenderableType]] = []
    self._filtered: list[tuple[str, RenderableType]] = []

def compose(self) -> ComposeResult:
    with Vertical():
        yield OptionList(id="options")
        yield Input(placeholder=self.placeholder, id="search-input")

def set_items(self, items: list[tuple[str, RenderableType]]) -> None:
    """Populate the pane with items and anchor the highlight."""
    self._items = items
    self._refresh_options()

@staticmethod
def _fuzzy_match(query: str, text: str) -> bool:
    """Fzf-style subsequence matching (e.g., 'mrc' matches 'master.tcss')."""
    query = query.lower()
    text = text.lower()
    iterator = iter(text)
    return all(char in iterator for char in query)

def _refresh_options(self, query: str = "") -> None:
    option_list = self.query_one("#options", OptionList)
    option_list.clear_options()

    if not query.strip():
        self._filtered = self._items
    else:
        self._filtered = [
            item for item in self._items 
            if self._fuzzy_match(query, item[0])
        ]

    for _, renderable in self._filtered:
        option_list.add_option(renderable)

    if self._filtered and option_list.highlighted is None:
        option_list.highlighted = 0

def get_highlighted_key(self) -> str | None:
    """Returns the text key of the currently highlighted option."""
    option_list = self.query_one("#options", OptionList)
    if option_list.highlighted is not None and 0 <= option_list.highlighted < len(self._filtered):
        return self._filtered[option_list.highlighted][0]
    return None

def on_input_changed(self, event: Input.Changed) -> None:
    if event.input.id != "search-input":
        return
    self._refresh_options(event.value)

def on_key(self, event: Key) -> None:
    """Handle smart focus switching between Input and OptionList."""
    input_widget = self.query_one("#search-input", Input)
    option_list = self.query_one("#options", OptionList)
         
    if event.is_printable and option_list.has_focus:
        input_widget.focus()
        if event.character:
            input_widget.value += event.character
        event.stop()
        
    elif event.key == "down" and input_widget.has_focus:
        option_list.focus()
        option_list.action_cursor_down()
        event.stop()
        
    elif event.key == "up" and input_widget.has_focus:
        option_list.focus()
        option_list.action_cursor_up()
        event.stop()`