xnano.components.table

def resolve_header(self) -> str:
    """Return the displayed header."""
    return self.header or self.name.replace("_", " ").title()

def resolve_value(self, row: Any) -> Any:
    """Read this column's value from a row."""
    if self.accessor is not None:
        return self.accessor(row)
    if isinstance(row, dict):
        return row.get(self.name)
    return getattr(row, self.name, None)

def resolve_text(self, value: Any) -> str:
    """Format a value for display."""
    if value is None:
        return ""
    if self.format is None:
        return str(value)
    if isinstance(self.format, str):
        return self.format.format(value)
    return self.format(value)

def resolve_color(self, value: Any) -> Any:
    """Resolve the foreground color for a value."""
    resolver = self.foreground
    return resolver(value) if callable(resolver) else resolver

def resolve_background(self, value: Any) -> Any:
    """Resolve the background color for a value."""
    return (
        self.background(value)
        if callable(self.background)
        else self.background
    )

def move(self, delta: int) -> int | None:
    """Move the selection by ``delta`` rows in display order.

    Args:
        delta: Positive moves down; negative moves up.

    Returns:
        The new selected index, or ``None`` when there is no data.
    """
    count = len(self.data)
    if count == 0:
        self.selected = None
        return None
    current = 0 if self.selected is None else self.selected
    self.selected = max(0, min(count - 1, current + delta))
    return self.selected

def handle_keyboard(self, keyboard: "KeyboardEventData") -> bool:
    """Navigate selection when ``focusable`` is enabled.

    Returns:
        ``True`` when the event was consumed.
    """
    if not self.focusable:
        return False
    for binding in self.passthrough:
        if keyboard.matches(binding):
            return False
    if keyboard.matches("up", "k"):
        self.move(-1)
        return True
    if keyboard.matches("down", "j"):
        self.move(1)
        return True
    if keyboard.matches("home"):
        if self.data:
            self.selected = 0
        return True
    if keyboard.matches("end"):
        if self.data:
            self.selected = len(self.data) - 1
        return True
    if keyboard.matches("pageup"):
        self.move(-10)
        return True
    if keyboard.matches("pagedown"):
        self.move(10)
        return True
    return False

def compose(self, ctx: "ComponentRenderContext"):
    """Compose TableGrid content with a native TableNode paint fallback.

    Returns:
        Interface-neutral content for this table.
    """
    return self._compose_table_grid()

def component_post_init(self) -> None:
    """Initialize subclass state after dataclass fields are assigned.

    Override this method instead of ``__post_init__``.
    """
    return None

def get_frame(self) -> Any | None:
    """Optional frame/panel chrome around composed content."""
    return None

def get_size(self, ctx: ComponentRenderContext[StateT]) -> Size:
    """Return the preferred cell size of this component."""
    return Size(width=0, height=0)

def before_render(
    self,
    ctx: ComponentRenderContext[StateT],
    area: "Area",
) -> "Area":
    """Called before rendering; returns the effective render area."""
    return area

def after_render(
    self,
    ctx: ComponentRenderContext[StateT],
    area: "Area",
) -> None:
    """Called after rendering for optional post-paint work."""
    return None

@responsive_noop
def compose_extra_small(
    self, ctx: ComponentRenderContext[StateT]
) -> Content | None:
    """Compose content when the viewport is extra small (< 40 cols).

    Optional responsive counterpart to :meth:`compose`. When
    overridden, it is used *instead of* ``compose`` while the window
    is in this size tier. Overriding any ``compose_*`` variant opts the
    component into breakpoint dispatch; a component that overrides none
    pays no per-frame cost.
    """
    return None

@responsive_noop
def compose_small(
    self, ctx: ComponentRenderContext[StateT]
) -> Content | None:
    """Compose content when the viewport is small (40–79 cols).

    See :meth:`compose_extra_small`.
    """
    return None

@responsive_noop
def compose_medium(
    self, ctx: ComponentRenderContext[StateT]
) -> Content | None:
    """Compose content when the viewport is medium (80–119 cols).

    See :meth:`compose_extra_small`.
    """
    return None

@responsive_noop
def compose_large(
    self, ctx: ComponentRenderContext[StateT]
) -> Content | None:
    """Compose content when the viewport is large (120–159 cols).

    See :meth:`compose_extra_small`.
    """
    return None

@responsive_noop
def compose_extra_large(
    self, ctx: ComponentRenderContext[StateT]
) -> Content | None:
    """Compose content when the viewport is extra large (>= 160 cols).

    See :meth:`compose_extra_small`.
    """
    return None

def handle_paste(self, text: str) -> bool:
    """Optional paste handler while focused.

    Returns:
        ``True`` when the paste was consumed.
    """
    return False