xnano.types

def contains(self, coordinate: Coordinate) -> bool:
    """Return whether ``coordinate`` lies inside this area."""
    column, row = coordinate
    return (
        self.x <= column < self.x + self.width
        and self.y <= row < self.y + self.height
    )

def fit_content(
    self,
    content: Size,
    horizontal: "Alignment | None" = None,
    vertical: "VerticalAlignment | None" = None,
) -> "Area":
    """Fit a measured size inside this area on both axes.

    Args:
        content: Measured content size, clamped to this area.
        horizontal: Horizontal placement (default ``"left"``).
        vertical: Vertical placement (default ``"top"``).

    Returns:
        The fitted, aligned area.
    """
    return align_area(
        self,
        min(self.width, max(content.width, 1)),
        min(self.height, max(content.height, 1)),
        horizontal=horizontal,
        vertical=vertical,
    )

@classmethod
def parse(cls, padding: PaddingLike | None) -> "Padding":
    """Normalize a padding value."""
    if padding is None:
        return cls()
    if isinstance(padding, cls):
        return padding
    if isinstance(padding, int):
        return cls(
            top=padding,
            right=padding,
            bottom=padding,
            left=padding,
        )
    values = cast(
        tuple[int, int]
        | tuple[int | None, int | None, int | None, int | None],
        padding,
    )
    if len(values) == 2:
        vertical, horizontal = values
        return cls(
            top=vertical or 0,
            right=horizontal or 0,
            bottom=vertical or 0,
            left=horizontal or 0,
        )
    top, right, bottom, left = values
    return cls(
        top=top or 0,
        right=right or 0,
        bottom=bottom or 0,
        left=left or 0,
    )

@classmethod
def from_tuple(cls, size: tuple[int, int]) -> "Size":
    """Create a size from ``(width, height)``."""
    return cls(width=size[0], height=size[1])

@classmethod
def from_int(cls, size: int) -> "Size":
    """Create a square size."""
    return cls(width=size, height=size)

@classmethod
def cells(cls, count: int) -> "Sizing":
    """Create a fixed cell size."""
    return cls(kind="cells", value=max(0, int(count)))

@classmethod
def percent(cls, percentage: float) -> "Sizing":
    """Create a percentage of the available length."""
    value = percentage * 100 if 0 <= percentage <= 1 else percentage
    return cls(kind="percent", value=max(0, min(100, round(value))))

@classmethod
def ratio(cls, numerator: int, denominator: int) -> "Sizing":
    """Create a ratio of the available length."""
    return cls(
        kind="ratio",
        value=max(0, int(numerator)),
        denominator=max(1, int(denominator)),
    )

@classmethod
def fraction(cls, weight: int = 1) -> "Sizing":
    """Create a proportional fill size."""
    return cls(kind="fraction", value=max(0, int(weight)))

@classmethod
def fit(
    cls,
    *,
    minimum: int | None = None,
    maximum: int | None = None,
) -> "Sizing":
    """Create a content-measured size."""
    return cls(kind="fit", minimum=minimum, maximum=maximum)

def with_bounds(
    self,
    *,
    minimum: int | None = None,
    maximum: int | None = None,
) -> "Sizing":
    """Return this size with new cell bounds."""
    return dataclasses.replace(self, minimum=minimum, maximum=maximum)

def resolve(self, available: int, content: int | None = None) -> int:
    """Resolve this size to cells."""
    if self.kind == "cells":
        length = self.value
    elif self.kind == "percent":
        length = available * self.value // 100
    elif self.kind == "ratio":
        length = available * self.value // self.denominator
    elif self.kind == "fit":
        length = content or 0
    else:
        length = available
    if self.minimum is not None:
        length = max(length, self.minimum)
    if self.maximum is not None:
        length = min(length, self.maximum)
    return max(0, length)

@classmethod
def parse(cls, value: "SizingLike | None") -> "Sizing | None":
    """Normalize a supported sizing value."""
    if value is None:
        return None
    if isinstance(value, cls):
        return value
    if isinstance(value, bool):
        raise TypeError("bool is not a valid sizing value")
    if isinstance(value, int):
        return cls.cells(value)
    if isinstance(value, float):
        return (
            cls.percent(value)
            if 0 <= value <= 1
            else cls.cells(round(value))
        )
    if not isinstance(value, str):
        raise TypeError(
            "sizing must be an int, float, str, or Sizing, "
            f"got {type(value).__name__}"
        )
    token = value.strip().lower()
    if token in ("fit", "auto", "content"):
        return cls.fit()
    if token == "full":
        # Matches the tailwind ``w-full`` / ``h-full`` rewrite: 100% of
        # the available axis length.
        return cls.percent(100)
    if token in ("fill", "grow"):
        return cls.fraction()
    if token in _FLEX_CLASS_WEIGHTS:
        return cls.fraction(_FLEX_CLASS_WEIGHTS[token])
    if token.endswith("%"):
        percentage = float(token[:-1])
        return cls(
            kind="percent",
            value=max(0, min(100, round(percentage))),
        )
    if token.endswith("fr"):
        return cls.fraction(int(token[:-2].strip() or "1"))
    if "/" in token:
        numerator, denominator = token.split("/", 1)
        return cls.ratio(int(numerator), int(denominator))
    try:
        return cls.cells(int(token))
    except ValueError as error:
        raise ValueError(f"invalid sizing string: {value!r}") from error

def is_empty(self) -> bool:
    """Return whether this frame has no visible attributes."""
    return not any(
        (
            self.background,
            self.border,
            self.border_color,
            self.border_sides,
            self.title,
            self.title_position,
            self.padding,
        )
    )

def scroll(self, delta: int) -> int:
    """Move the offset by ``delta`` cells."""
    self.offset = max(0, self.offset + delta)
    if delta:
        self.follow = False
    return self.offset

def scroll_to(self, offset: int) -> int:
    """Set the offset in cells."""
    self.offset = max(0, offset)
    self.follow = False
    return self.offset

def scroll_to_end(self) -> None:
    """Follow the end of the content."""
    self.follow = True