termtui 0.1.0

A framework for building beautiful, responsive terminal user interfaces with a DOM-style hierarchical approach
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::app::Context;
use crate::node::Node;
use std::any::Any;
use std::fmt::Debug;

//--------------------------------------------------------------------------------------------------
// Types
//--------------------------------------------------------------------------------------------------

/// Action returned by a component's update method
pub enum Action {
    /// Update the component's state
    Update(Box<dyn State>),

    /// Update a topic's state (idempotent - first writer becomes owner)
    UpdateTopic(String, Box<dyn State>),

    /// No action needed
    None,

    /// Exit the application
    Exit,
}

/// Unique identifier for components in the tree
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ComponentId(pub String);

/// Trait for messages that can be sent between components
pub trait Message: Any + Send + 'static {
    fn as_any(&self) -> &dyn Any;
    fn clone_box(&self) -> Box<dyn Message>;
}

/// Extension trait for convenient message downcasting
pub trait MessageExt {
    /// Downcast the message to a concrete type
    fn downcast<T: Any>(&self) -> Option<&T>;
}

impl MessageExt for dyn Message {
    fn downcast<T: Any>(&self) -> Option<&T> {
        self.as_any().downcast_ref::<T>()
    }
}

impl MessageExt for Box<dyn Message> {
    fn downcast<T: Any>(&self) -> Option<&T> {
        self.as_any().downcast_ref::<T>()
    }
}

/// Trait for component state management
pub trait State: Any + Send + 'static {
    fn as_any(&self) -> &dyn Any;
    fn as_any_mut(&mut self) -> &mut dyn Any;
    fn clone_box(&self) -> Box<dyn State>;
}

/// Extension trait for convenient state downcasting
pub trait StateExt {
    /// Downcast the state to a concrete type
    fn downcast<T: Any>(&self) -> Option<&T>;
}

impl StateExt for dyn State {
    fn downcast<T: Any>(&self) -> Option<&T> {
        self.as_any().downcast_ref::<T>()
    }
}

impl StateExt for Box<dyn State> {
    fn downcast<T: Any>(&self) -> Option<&T> {
        self.as_any().downcast_ref::<T>()
    }
}

/// Auto-implementation of State for types that are Clone
impl<T> State for T
where
    T: Any + Clone + Send + 'static,
{
    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }

    fn clone_box(&self) -> Box<dyn State> {
        Box::new(self.clone())
    }
}

/// Main component trait for building UI components
pub trait Component: 'static {
    fn update(&self, ctx: &Context, msg: Box<dyn Message>, topic: Option<&str>) -> Action;

    fn view(&self, ctx: &Context) -> Node;

    fn get_id(&self) -> Option<ComponentId>;

    fn set_id(&mut self, id: ComponentId);

    fn as_any(&self) -> &dyn Any;

    fn as_any_mut(&mut self) -> &mut dyn Any;

    fn clone_box(&self) -> Box<dyn Component>;
}

/// Helper trait for cloning Component trait objects
pub trait ComponentClone {
    fn clone_box(&self) -> Box<dyn Component>;
}

//--------------------------------------------------------------------------------------------------
// Methods
//--------------------------------------------------------------------------------------------------

impl ComponentId {
    pub fn new(id: impl Into<String>) -> Self {
        Self(id.into())
    }

    pub fn child(&self, index: usize) -> Self {
        Self(format!("{}.{}", self.0, index))
    }
}

//--------------------------------------------------------------------------------------------------
// Trait Implementations
//--------------------------------------------------------------------------------------------------

impl Default for ComponentId {
    fn default() -> Self {
        Self("0".to_string())
    }
}

impl<T> Message for T
where
    T: Any + Clone + Send + 'static,
{
    fn as_any(&self) -> &dyn Any {
        self
    }

    fn clone_box(&self) -> Box<dyn Message> {
        Box::new(self.clone())
    }
}

impl<T> ComponentClone for T
where
    T: Component + Clone + 'static,
{
    fn clone_box(&self) -> Box<dyn Component> {
        Box::new(self.clone())
    }
}