aura-gui 0.2.1

UI nativa acelerada por GPU para escritorio, Android e iOS, en un solo crate: estilo tipo Tailwind, componentes, sombras, animaciones y agentes de IA. Reposo a cero. Licencia AGPL-3.0 o comercial.
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

//! # Aura UI
//!
//! Interfaces nativas aceleradas por GPU para **macOS, Windows, Linux, Android e iOS** con un solo código:
//! estilo encadenado al estilo Tailwind, componentes al estilo shadcn, sombras y animaciones.
//!
//! Eficiente por defecto: el bucle duerme cuando no pasa nada (CPU en reposo ≈ 0), pinta solo lo que se ve, usa
//! la GPU integrada de bajo consumo con un único frame en cola y suelta cachés al pasar a segundo plano o cuando
//! el sistema avisa de poca memoria.
//!
//! ```no_run
//! use aura_ui::prelude::*;
//!
//! struct Contador {
//!     clics: u32,
//! }
//!
//! impl Render for Contador {
//!     fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement {
//!         div()
//!             .size_full()
//!             .flex_col()
//!             .items_center()
//!             .justify_center()
//!             .gap_4()
//!             .bg(Token::Canvas)
//!             .text_color(Token::Text)
//!             .child(div().p_6().rounded_lg().bg(Token::ElevatedSurface).shadow_md().child(format!("Clics: {}", self.clics)))
//!             .child(Button::new("Sumar").variant(ButtonVariant::Primary).on_click(cx.click(|this, _| this.clics += 1)))
//!             .into_element()
//!     }
//! }
//!
//! aura_ui::main!(AppOptions::new("Contador"), |window| window.set_root(Contador { clics: 0 }));
//! # fn _usa_main() { main() }
//! ```
//!
//! ## Licencia
//!
//! Doble licencia: **AGPL-3.0** (gratis; tu app también debe publicarse bajo AGPL-3.0) o la
//! **licencia comercial** de Aura UI para apps cerradas, con regalías del 10% de los ingresos. Ver
//! `LICENSE-COMMERCIAL.md`.

#![doc(html_no_source)]

/// Núcleo: entidades, tareas, temporizadores, geometría, color, animaciones y capa de sistema.
pub mod core;
/// Renderizador sobre wgpu (Metal, Vulkan, DirectX 12, OpenGL ES) con respaldo por CPU.
pub mod gpu;
/// Elementos, estilo, layout flexbox, foco, teclado, temas y accesibilidad.
pub mod view;
/// Componentes listos: botones, insignias, pestañas, entradas de texto, menús, selectores, avisos.
pub mod widgets;
/// Ventana, bucle de eventos, gestos táctiles y ciclo de vida en escritorio y móvil.
pub mod app;
/// Agentes de IA: proveedores HTTP, ACP y MCP, sesión OAuth y almacén de claves. Feature `ai` (activa por defecto).
#[cfg(feature = "ai")]
pub mod ai;

pub use app::{AppOptions, run};

/// Todo lo necesario para escribir una app con un solo `use aura_ui::prelude::*;`.
pub mod prelude {
    pub use crate::app::{AppOptions, run};
    pub use crate::core::platform::{JsonExt, Store};
    pub use crate::view::prelude::*;
    pub use crate::widgets::{
        Badge, BadgeVariant, Button, ButtonVariant, IconButton, IconName, chip, icon, modal, switch, toast, tool_button,
    };
}

/// Acepta cierres que devuelven algo (`window.set_root(..)` devuelve el handle) y lo descarta.
#[doc(hidden)]
pub fn __build<R>(
    build: impl FnOnce(&mut crate::view::window::Window) -> R + 'static,
) -> impl FnOnce(&mut crate::view::window::Window) + 'static {
    move |window| {
        build(window);
    }
}

/// Punto de entrada multiplataforma. Genera `pub fn main()` en escritorio e iOS y `android_main` en Android
/// (la crate se compila como `cdylib`), así que el mismo código sirve para todos los sistemas.
///
/// ```ignore
/// aura_ui::main!(aura_ui::AppOptions::new("Mi app"), |window| window.set_root(MiVista));
/// ```
#[macro_export]
macro_rules! main {
    ($options:expr, $build:expr $(,)?) => {
        #[cfg(not(target_os = "android"))]
        pub fn main() {
            if let Err(error) = $crate::run($options, $crate::__build($build)) {
                eprintln!("{error}");
                std::process::exit(1);
            }
        }

        #[cfg(target_os = "android")]
        #[unsafe(no_mangle)]
        fn android_main(android: $crate::app::AndroidApp) {
            if let Err(error) = $crate::run(($options).android_app(android), $crate::__build($build)) {
                eprintln!("{error}");
            }
        }
    };
}