use tea_protocol::{BranchId, ModelRef, ReasoningEffort, SessionId};
const MAX_SELECTOR_ITEMS: usize = 512;
const MAX_SELECTOR_QUERY_BYTES: usize = 256;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SelectorValue {
Session(SessionId),
Model(ModelRef),
Reasoning(ReasoningEffort),
Branch(BranchId),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SelectorItem {
label: String,
value: SelectorValue,
}
impl SelectorItem {
#[must_use]
pub fn new(label: impl Into<String>, value: SelectorValue) -> Self {
Self {
label: label.into(),
value,
}
}
#[must_use]
pub fn label(&self) -> &str {
&self.label
}
#[must_use]
pub const fn value(&self) -> &SelectorValue {
&self.value
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
pub enum SelectorError {
#[error("selector is invalid")]
Invalid,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Selector {
title: String,
items: Vec<SelectorItem>,
visible: Vec<usize>,
query: String,
selected: usize,
}
impl Selector {
pub fn new<I>(title: impl Into<String>, items: I) -> Result<Self, SelectorError>
where
I: IntoIterator<Item = SelectorItem>,
{
let title = title.into();
let items = items.into_iter().collect::<Vec<_>>();
if !valid_text(&title)
|| items.len() > MAX_SELECTOR_ITEMS
|| items.iter().any(|item| !valid_text(&item.label))
{
return Err(SelectorError::Invalid);
}
let visible = (0..items.len()).collect();
Ok(Self {
title,
items,
visible,
query: String::new(),
selected: 0,
})
}
#[must_use]
pub fn title(&self) -> &str {
&self.title
}
#[must_use]
pub fn query(&self) -> &str {
&self.query
}
pub fn set_query(&mut self, query: &str) {
let mut boundary = query.len().min(MAX_SELECTOR_QUERY_BYTES);
while !query.is_char_boundary(boundary) {
boundary -= 1;
}
query[..boundary].clone_into(&mut self.query);
let query = self.query.to_lowercase();
self.visible = self
.items
.iter()
.enumerate()
.filter_map(|(index, item)| item.label.to_lowercase().contains(&query).then_some(index))
.collect();
self.selected = 0;
}
#[must_use]
pub fn visible_items(&self) -> Vec<&SelectorItem> {
self.visible
.iter()
.map(|index| &self.items[*index])
.collect()
}
pub fn move_next(&mut self) {
if !self.visible.is_empty() {
self.selected = (self.selected + 1) % self.visible.len();
}
}
pub fn move_previous(&mut self) {
if !self.visible.is_empty() {
self.selected = self
.selected
.checked_sub(1)
.unwrap_or(self.visible.len() - 1);
}
}
pub fn select_value(&mut self, value: &SelectorValue) {
if let Some(index) = self
.visible
.iter()
.position(|index| self.items[*index].value == *value)
{
self.selected = index;
}
}
#[must_use]
pub fn selected_label(&self) -> Option<&str> {
self.visible
.get(self.selected)
.map(|index| self.items[*index].label.as_str())
}
#[must_use]
pub fn accept(&self) -> Option<SelectorValue> {
self.visible
.get(self.selected)
.map(|index| self.items[*index].value.clone())
}
}
fn valid_text(value: &str) -> bool {
!value.is_empty() && value.len() <= 512 && !value.chars().any(char::is_control)
}