Skip to main content

grio/components/
mod.rs

1//! Composants de l'UI : éléments modulaires exposés à l'utilisateur du moteur.
2//!
3//! Chaque composant est déclaré via son constructeur, configuré par chaînage
4//! de méthodes (builder), puis inséré dans un conteneur ou à la racine de
5//! l'application (`App::item`, `App::row`, …).
6//!
7//! Le rôle de chaque composant (`Role::Input` / `Role::Output`) est
8//! déclaratif : il permet d'identifier automatiquement les entrées et les
9//! sorties, donc de générer l'API REST (`/api/predict`, `/api/schema`).
10
11use serde_json::{json, Value};
12
13pub mod data;
14pub mod forms;
15pub mod layout;
16pub mod media;
17pub mod special;
18
19pub use data::*;
20pub use forms::*;
21pub use layout::*;
22pub use media::*;
23pub use special::*;
24
25/// Rôle d'un composant pour l'API REST automatique.
26///
27/// * `Input` — composant d'entrée : ses valeurs alimentent `on_submit`.
28/// * `Output` — composant de sortie : il reçoit les résultats calculés.
29/// * `None` — aucun rôle (boutons, conteneurs, décoration).
30#[derive(Clone, Copy, Debug, PartialEq, Eq)]
31pub enum Role {
32    /// Composant d'entrée : alimente `on_submit` et `/api/predict`.
33    Input,
34    /// Composant de sortie : reçoit les résultats.
35    Output,
36    /// Aucun rôle (boutons, conteneurs, décoration).
37    None,
38}
39
40/// Contrat minimal d'un composant.
41///
42/// Un type qui implémente `Component` est utilisable n'importe où dans
43/// l'arbre de l'application. Le rendu lui-même est délégué au front
44/// (`app.js`), le serveur ne transmet qu'un identifiant, un « kind » et une
45/// configuration JSON (`props`).
46pub trait Component: Send + Sync {
47    /// Identifiant unique du composant — cible des événements et licences
48    /// `ctx.get/set`.
49    fn id(&self) -> &str;
50
51    /// Nom logique du composant (ex. `"text"`, `"slider"`, `"row"`). Doit
52    /// correspondre à une entrée du registre JavaScript.
53    fn kind(&self) -> &'static str;
54
55    /// Configuration sérialisée envoyée au client au montage.
56    fn props(&self) -> Value;
57
58    /// Rôle pour le classement automatique de l'API REST.
59    fn role(&self) -> Role {
60        Role::None
61    }
62
63    /// Mise en page commune (dimensions, proportion) — fusionnée dans
64    /// `props` au rendu par le serveur. Vaut `None` partout par défaut.
65    fn layout(&self) -> Layout {
66        Layout::default()
67    }
68
69    /// Enfants — utilisé pour le rendu récursif des conteneurs.
70    fn children(&self) -> Vec<&dyn Component> {
71        Vec::new()
72    }
73}
74
75/// Mise en page commune à **tous** les composants : dimensions en pixels et
76/// proportion relative au sein d'une ligne (comme `scale`/`min_width` de
77/// Gradio). Les réglages non remplis (`None`) sont simplement omis du rendu.
78#[derive(Clone, Copy, Debug, Default, PartialEq)]
79pub struct Layout {
80    /// Largeur en pixels (CSS `width`).
81    pub width: Option<u32>,
82    /// Hauteur en pixels (CSS `height`).
83    pub height: Option<u32>,
84    /// Largeur maximale en pixels (CSS `max-width`).
85    pub max_width: Option<u32>,
86    /// Hauteur maximale en pixels (CSS `max-height`).
87    pub max_height: Option<u32>,
88    /// Proportion relative dans la ligne (CSS `flex-grow`).
89    pub scale: Option<u32>,
90    /// Largeur minimale en pixels (CSS `min-width`).
91    pub min_width: Option<u32>,
92}
93
94impl Layout {
95    /// JSON des seuls réglages non vides — fusionné dans `props` au rendu.
96    pub fn json(self) -> Value {
97        let mut o = serde_json::Map::new();
98        if let Some(w) = self.width {
99            o.insert("width".into(), json!(w));
100        }
101        if let Some(h) = self.height {
102            o.insert("height".into(), json!(h));
103        }
104        if let Some(mw) = self.max_width {
105            o.insert("max_width".into(), json!(mw));
106        }
107        if let Some(mh) = self.max_height {
108            o.insert("max_height".into(), json!(mh));
109        }
110        if let Some(s) = self.scale {
111            o.insert("scale".into(), json!(s));
112        }
113        if let Some(m) = self.min_width {
114            o.insert("min_width".into(), json!(m));
115        }
116        Value::Object(o)
117    }
118}
119
120/// Enveloppe **modulaire** : ajoute une mise en page (`.width()`, `.height()`,
121/// `.scale()`, `.min_width()`) à n'importe quel composant — brique **ou**
122/// conteneur (`Row`/`Column`/`Panel` construits à la main) — sans rien
123/// modifier au type d'origine :
124///
125/// ```rust
126/// # use grio::*;
127/// WithLayout::new(Text::new("a")).width(240).min_width(120);
128/// WithLayout::new(Row::new("r").item(Text::new("a"))).scale(2);
129/// ```
130pub struct WithLayout<C> {
131    inner: C,
132    layout: Layout,
133}
134
135impl<C: Component> WithLayout<C> {
136    /// Enveloppe `inner` avec une mise en page vide.
137    pub fn new(inner: C) -> Self {
138        Self {
139            inner,
140            layout: Layout::default(),
141        }
142    }
143    /// Largeur en pixels.
144    pub fn width(mut self, w: u32) -> Self {
145        self.layout.width = Some(w);
146        self
147    }
148    /// Hauteur en pixels.
149    pub fn height(mut self, h: u32) -> Self {
150        self.layout.height = Some(h);
151        self
152    }
153    /// Largeur maximale en pixels.
154    pub fn max_width(mut self, mw: u32) -> Self {
155        self.layout.max_width = Some(mw);
156        self
157    }
158    /// Hauteur maximale en pixels.
159    pub fn max_height(mut self, mh: u32) -> Self {
160        self.layout.max_height = Some(mh);
161        self
162    }
163    /// Proportion relative dans la ligne (comme `scale` de Gradio).
164    pub fn scale(mut self, s: u32) -> Self {
165        self.layout.scale = Some(s);
166        self
167    }
168    /// Largeur minimale en pixels.
169    pub fn min_width(mut self, w: u32) -> Self {
170        self.layout.min_width = Some(w);
171        self
172    }
173    /// Remplace la mise en page en un appel.
174    pub fn set_layout(mut self, l: Layout) -> Self {
175        self.layout = l;
176        self
177    }
178    /// Restitue le composant d'origine.
179    pub fn into_inner(self) -> C {
180        self.inner
181    }
182    /// Réglage courant.
183    pub fn layout(&self) -> Layout {
184        self.layout
185    }
186}
187
188impl<C: Component> Component for WithLayout<C> {
189    fn id(&self) -> &str {
190        self.inner.id()
191    }
192    fn kind(&self) -> &'static str {
193        self.inner.kind()
194    }
195    fn props(&self) -> Value {
196        self.inner.props()
197    }
198    fn role(&self) -> Role {
199        self.inner.role()
200    }
201    fn children(&self) -> Vec<&dyn Component> {
202        self.inner.children()
203    }
204    fn layout(&self) -> Layout {
205        self.layout
206    }
207}
208
209/// Conversion commode `T: Component → Box<dyn Component>`.
210pub trait IntoBox {
211    /// Emboîte la valeur dans un trait-objet.
212    fn into_box(self) -> Box<dyn Component>;
213}
214
215impl<T> IntoBox for T
216where
217    T: Component + 'static,
218{
219    fn into_box(self) -> Box<dyn Component> {
220        Box::new(self)
221    }
222}
223
224pub(crate) fn children_refs(items: &[Box<dyn Component>]) -> Vec<&dyn Component> {
225    items.iter().map(|b| b.as_ref() as &dyn Component).collect()
226}