aura-gui 0.3.5

//! # 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::*;
//!
//! fn main() {
//!     run_app("Contador", |ui| {
//!         let clics = ui.state("clics", 0u32);
//!         ui.page().center().gap_4()
//!             .child(ui.card().p_6().child(format!("Clics: {}", clics.get())))
//!             .child(ui.button("Sumar").on_click(clics.update(|n| *n += 1)))
//!     });
//! }
//! ```
//!
//! La app es una closure; el estado vive en `ui.state("clave", valor)` y los manejadores se crean con
//! `state.update(...)`, `state.set(...)` o `state.toggle()`. No hay `impl` ni `AppOptions` en el camino
//! normal. Los componentes y recetas usan los tokens del tema, así que la interfaz se ve coherente sin elegir
//! colores a mano.
//!
//! ## 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, run_app};

/// Todo lo necesario para escribir una app con un solo `use aura_ui::prelude::*;`.
pub mod prelude {
    pub use crate::app::{AppOptions, run, run_app};
    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,
        InputSubmitted, 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,
    };
    pub use crate::{column, row};
}

/// 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 app
/// normal usa [`run_app`]; este macro queda para el arranque avanzado y para Android.
///
/// ```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}");
            }
        }
    };
}

/// Columna con hijos, sin repetir `.child(...)`: `column![titulo, boton]`.
///
/// Devuelve un `Div` con `flex_col`; se encadena como cualquier elemento (`.gap_4()`, `.p_6()`…).
#[macro_export]
macro_rules! column {
    ($($child:expr),* $(,)?) => {
        $crate::view::div::div().flex_col() $(.child($child))*
    };
}

/// Fila con hijos, sin repetir `.child(...)`: `row![icono, texto]`.
#[macro_export]
macro_rules! row {
    ($($child:expr),* $(,)?) => {
        $crate::view::div::div().flex_row().items_center() $(.child($child))*
    };
}

/// Registra una vista escrita como función, sin escribir `impl`.
///
/// Es el puente para las apps que ya tienen estado en entidades (`Handle`/`ViewContext`): se mueve el cuerpo del
/// antiguo `impl` a una función y se registra con esta macro. La app no escribe `impl`; la API de closure sigue
/// siendo la recomendada para apps nuevas.
///
/// ```ignore
/// fn panel_view(this: &mut Panel, cx: &mut ViewContext<Panel>) -> AnyElement { ... }
/// aura_ui::component!(Panel, panel_view);
/// ```
#[macro_export]
macro_rules! component {
    ($ty:ty, $view:path) => {
        impl $crate::view::render::Component for $ty {
            fn view(
                &mut self,
                cx: &mut $crate::view::render::ViewContext<Self>,
            ) -> impl $crate::view::element::IntoElement {
                $view(self, cx)
            }
        }
    };
}