osui 0.2.0

A TUI library for advanced uis
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

//! # Frontend Module
//!
//! Provides the RSX (React-like Syntax) system for composing components.
//! This module defines the structure for building component hierarchies
//! with static and dynamic scopes, similar to React's JSX.

use std::sync::Arc;

use crate::component::{context::Context, scope::Scope};
use crate::{render::Point, state::HookDependency, View};

/// Trait for converting values to RSX
pub trait ToRsx {
    /// Convert to RSX representation
    fn to_rsx(&self) -> Rsx;
}

/// Scope types for RSX components
#[derive(Clone)]
pub enum RsxScope {
    /// Static scope - executed once and never updated
    Static(Arc<dyn Fn(&Arc<Scope>) + Send + Sync>),
    /// Dynamic scope - re-executed when dependencies change
    Dynamic(
        Arc<dyn Fn(&Arc<Scope>) + Send + Sync>,
        Vec<Arc<dyn HookDependency>>,
    ),
    /// Child RSX scope for composition
    Child(Rsx),
}

/// RSX (React-like Syntax) builder for component hierarchies
/// 
/// Represents a collection of scopes that define component structure.
/// Scopes can be static (execute once) or dynamic (reactive to changes).
#[derive(Clone)]
pub struct Rsx(Vec<RsxScope>);

impl Rsx {
    /// Creates a new empty RSX
    pub fn new() -> Self {
        Self(Vec::new())
    }

    /// Adds a static scope to this RSX
    /// 
    /// The provided function is executed once during rendering
    /// and will not be re-executed on dependency changes.
    pub fn static_scope<F: Fn(&Arc<Scope>) + Send + Sync + 'static>(&mut self, scope: F) {
        self.0.push(RsxScope::Static(Arc::new(scope)));
    }

    /// Adds a dynamic scope to this RSX
    /// 
    /// The provided function is executed when dependencies change,
    /// allowing for reactive updates similar to React hooks.
    pub fn dynamic_scope<F: Fn(&Arc<Scope>) + Send + Sync + 'static>(
        &mut self,
        drawer: F,
        dependencies: Vec<Arc<dyn HookDependency>>,
    ) {
        self.0
            .push(RsxScope::Dynamic(Arc::new(drawer), dependencies));
    }

    /// Adds a child RSX
    pub fn child<R: ToRsx>(&mut self, child: R) {
        self.0.push(RsxScope::Child(child.to_rsx()));
    }

    /// Generates child components within the given context
    pub fn generate_children(&self, context: &Arc<Context>) {
        let executor = context.get_executor();

        for scope in &self.0 {
            match scope {
                RsxScope::Static(scope_fn) => {
                    let scope = Scope::new(executor.clone());
                    (scope_fn)(&scope);
                    context.add_scope(scope)
                }
                RsxScope::Dynamic(drawer, dependencies) => {
                    let drawer = drawer.clone();
                    context.dyn_scope(
                        move |c| drawer(c),
                        &dependencies.iter().map(|d| d.as_ref()).collect::<Vec<_>>(),
                    );
                }
                RsxScope::Child(child) => child.generate_children(context),
            }
        }
    }

    /// Converts this RSX to a View
    pub fn view(&self, context: &Arc<Context>) -> View {
        let context = context.clone();

        self.generate_children(&context);

        Arc::new({
            move |ctx| {
                context.draw_children(ctx);
            }
        })
    }
}

impl ToRsx for &Rsx {
    fn to_rsx(&self) -> Rsx {
        Rsx(self.0.clone())
    }
}

impl<T: std::fmt::Display> ToRsx for T {
    fn to_rsx(&self) -> Rsx {
        let s = self.to_string();
        Rsx(vec![RsxScope::Static(Arc::new(move |scope| {
            let s = s.clone();
            scope.view(Arc::new(move |ctx| ctx.draw_text(Point { x: 0, y: 0 }, &s)))
        }))])
    }
}