lurq 0.65.1

A Rust UI toolkit with typed components, retained state, reactive signals, GPU rendering, and DevTools.
Documentation
use std::{collections::BTreeMap, sync::Arc};

use crate::app::component::{ComponentInfo, DevtoolsInspectable};

#[derive(Clone, Debug, PartialEq)]
pub enum FormValue {
  String(Arc<str>),
  Number(f64),
  Bool(bool),
  /// A range slider's two values, the low one first.
  Range(f64, f64),
}

impl FormValue {
  pub fn as_str(&self) -> Option<&str> {
    match self {
      Self::String(value) => Some(value),
      _ => None,
    }
  }

  pub fn as_number(&self) -> Option<f64> {
    match self {
      Self::Number(value) => Some(*value),
      _ => None,
    }
  }

  pub fn as_bool(&self) -> Option<bool> {
    match self {
      Self::Bool(value) => Some(*value),
      _ => None,
    }
  }

  /// A range's low value and its high one.
  pub fn as_range(&self) -> Option<(f64, f64)> {
    match self {
      Self::Range(low, high) => Some((*low, *high)),
      _ => None,
    }
  }

  pub(crate) fn to_string_value(&self) -> String {
    match self {
      Self::String(value) => value.to_string(),
      Self::Number(value) => value.to_string(),
      Self::Bool(value) => value.to_string(),
      Self::Range(low, high) => format!("{low},{high}"),
    }
  }
}

impl DevtoolsInspectable for FormValue {
  fn write_info(&self, buffer: &mut Vec<ComponentInfo>) {
    buffer.push(ComponentInfo::with_value(
      "value",
      std::any::type_name::<Self>(),
      match self {
        Self::String(value) => format!("{value:?}"),
        Self::Number(value) => value.to_string(),
        Self::Bool(value) => value.to_string(),
        Self::Range(low, high) => format!("({low}, {high})"),
      },
    ));
  }
}

impl From<&str> for FormValue {
  fn from(value: &str) -> Self {
    Self::String(Arc::from(value))
  }
}

impl From<String> for FormValue {
  fn from(value: String) -> Self {
    Self::String(Arc::from(value))
  }
}

impl From<Arc<str>> for FormValue {
  fn from(value: Arc<str>) -> Self {
    Self::String(value)
  }
}

impl From<bool> for FormValue {
  fn from(value: bool) -> Self {
    Self::Bool(value)
  }
}

impl From<i32> for FormValue {
  fn from(value: i32) -> Self {
    Self::Number(value as f64)
  }
}

impl From<f64> for FormValue {
  fn from(value: f64) -> Self {
    Self::Number(value)
  }
}

impl From<(f64, f64)> for FormValue {
  fn from((low, high): (f64, f64)) -> Self {
    Self::Range(low, high)
  }
}

impl From<(i32, i32)> for FormValue {
  fn from((low, high): (i32, i32)) -> Self {
    Self::Range(low as f64, high as f64)
  }
}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct FormValues {
  fields: BTreeMap<Arc<str>, FormValue>,
}

impl FormValues {
  pub fn new() -> Self {
    <Self as Default>::default()
  }

  pub fn with(mut self, name: impl Into<Arc<str>>, value: impl Into<FormValue>) -> Self {
    self.set(name, value);
    self
  }

  pub fn set(&mut self, name: impl Into<Arc<str>>, value: impl Into<FormValue>) {
    self.fields.insert(name.into(), value.into());
  }

  pub fn get(&self, name: &str) -> Option<&FormValue> {
    self.fields.get(name)
  }

  pub(crate) fn contains(&self, name: &str) -> bool {
    self.fields.contains_key(name)
  }

  pub(crate) fn remove(&mut self, name: &str) {
    self.fields.remove(name);
  }

  pub fn get_string(&self, name: &str) -> Option<&str> {
    self.get(name).and_then(FormValue::as_str)
  }

  pub fn get_number(&self, name: &str) -> Option<f64> {
    self.get(name).and_then(FormValue::as_number)
  }

  pub fn get_bool(&self, name: &str) -> Option<bool> {
    self.get(name).and_then(FormValue::as_bool)
  }

  /// A range slider's two values under `name`, the low one first.
  pub fn get_range(&self, name: &str) -> Option<(f64, f64)> {
    self.get(name).and_then(FormValue::as_range)
  }

  pub fn entries(&self) -> impl Iterator<Item = (&str, &FormValue)> {
    self.fields.iter().map(|(name, value)| (name.as_ref(), value))
  }

  pub fn len(&self) -> usize {
    self.fields.len()
  }

  pub fn is_empty(&self) -> bool {
    self.fields.is_empty()
  }
}

impl DevtoolsInspectable for FormValues {
  fn write_info(&self, buffer: &mut Vec<ComponentInfo>) {
    let children = self
      .entries()
      .map(|(name, value)| {
        ComponentInfo::with_value(
          "field",
          std::any::type_name::<FormValue>(),
          format!("{name}: {value:?}"),
        )
      })
      .collect();
    buffer.push(ComponentInfo::with_children(
      "values",
      std::any::type_name::<Self>(),
      children,
    ));
  }
}

impl<const N: usize> From<[(&str, FormValue); N]> for FormValues {
  fn from(values: [(&str, FormValue); N]) -> Self {
    values
      .into_iter()
      .fold(Self::new(), |values, (name, value)| values.with(name, value))
  }
}