aura-gui 0.2.2

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! # 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 View for Contador {
//!     fn view(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
//!         div().page().center().gap_4()
//!             .child(div().card().p_6().child(format!("Clics: {}", self.clics)))
//!             .child(Button::new("Sumar").on_click(cx.click(|this, _| this.clics += 1)))
//!     }
//! }
//!
//! aura_ui::app!(AppOptions::new("Contador"), 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)]

/// 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;
/// Ventana, bucle de eventos, gestos táctiles y ciclo de vida en escritorio y móvil.
pub mod app;
/// 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 y recetas (`.page()`, `.card()`…), layout, foco, teclado, temas y accesibilidad.
pub mod view;
/// Componentes listos: botones, insignias, pestañas, entradas, menús, selectores, avisos y estructura de pantalla.
pub mod widgets;

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, ContextMenu, IconButton, IconName, InputAppearance, InputChanged,
        MenuItem, Picker, PickerDelegate, PickerEvent, Sidebar, SplitDirection, SplitPane, StatusBar, Tab, TabBar,
        TextInput, TreeItem, chip, empty_state, field, horizontal_separator, icon, kbd, modal, page_header,
        scroll_view, section, setting_row, switch, toast, toast_with, tool_button, vertical_separator,
    };
}

/// 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.
///
/// Recibe un cierre que prepara la ventana (keymap, entidades compartidas…) y monta la vista raíz. Para una
/// vista directa, sin preparativos, usa [`app!`].
///
/// ```ignore
/// aura_ui::main!(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}");
            }
        }
    };
}

/// Punto de entrada multiplataforma para una vista directa, sin preparar la ventana a mano.
///
/// Es azúcar sobre [`main!`]; si necesitas configurar el keymap o crear entidades antes de montar la vista,
/// usa `main!` o [`AppOptions::run`].
///
/// ```ignore
/// aura_ui::app!(AppOptions::new("Mi app"), MiVista);
/// ```
#[macro_export]
macro_rules! app {
    ($options:expr, $view:expr $(,)?) => {
        $crate::main!($options, move |__window| {
            __window.set_root($view);
        });
    };
}