cronixui 1.0.6 → 1.1.1

package/packages/rust/cronixui/src/components/file_input.rs

@@ -0,0 +1,74 @@
+//! File input component
+
+use egui::*;
+use crate::{colors::*, tokens::*};
+
+pub struct FileInput {
+    pub accept: String,
+    pub multiple: bool,
+    pub files: Vec<String>,
+}
+
+impl FileInput {
+    pub fn new() -> Self {
+        Self { accept: String::new(), multiple: false, files: Vec::new() }
+    }
+
+    pub fn accept(mut self, accept: impl Into<String>) -> Self {
+        self.accept = accept.into();
+        self
+    }
+
+    pub fn multiple(mut self) -> Self {
+        self.multiple = true;
+        self
+    }
+
+    pub fn show(&mut self, ui: &mut Ui) -> Response {
+        let colors = Colors::default();
+
+        egui::Frame::none()
+            .fill(colors.surface)
+            .stroke(egui::Stroke::new(1.0, colors.border))
+            .rounding(Rounding::same(tokens::RADIUS))
+            .inner_margin(tokens::SPACE_4)
+            .show(ui, |ui| {
+                ui.vertical(|ui| {
+                    ui.label(
+                        RichText::new("📁 Drop files here or click to browse")
+                            .size(tokens::FONT_SIZE_BASE)
+                            .color(colors.text_muted),
+                    );
+
+                    if ui.button_primary("Browse files").clicked() {
+                        // Note: actual file selection requires platform-specific code
+                        // This is a UI placeholder
+                    }
+
+                    if !self.files.is_empty() {
+                        ui.add_space(tokens::SPACE_2);
+                        ui.separator();
+                        ui.add_space(tokens::SPACE_2);
+
+                        for file in &self.files {
+                            ui.horizontal(|ui| {
+                                ui.label("📄");
+                                ui.label(
+                                    RichText::new(file)
+                                        .size(tokens::FONT_SIZE_SM)
+                                        .color(colors.text),
+                                );
+                            });
+                        }
+                    }
+                });
+            })
+            .response
+    }
+}
+
+impl Default for FileInput {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/packages/rust/cronixui/src/components/input.rs

@@ -0,0 +1,21 @@
+//! Input component
+
+use egui::{TextEdit, Ui};
+
+use crate::tokens::*;
+
+pub fn input(ui: &mut Ui, text: &mut String, placeholder: &str) -> egui::Response {
+    ui.add(TextEdit::singleline(text).hint_text(placeholder).desired_width(f32::INFINITY))
+}
+
+pub fn textarea(ui: &mut Ui, text: &mut String, placeholder: &str) -> egui::Response {
+    ui.add(TextEdit::multiline(text).hint_text(placeholder))
+}
+
+pub fn password(ui: &mut Ui, text: &mut String, placeholder: &str) -> egui::Response {
+    ui.add(TextEdit::singleline(text).hint_text(placeholder).password(true))
+}
+
+pub fn search(ui: &mut Ui, text: &mut String) -> egui::Response {
+    ui.add(TextEdit::singleline(text).hint_text("Search...").desired_width(f32::INFINITY))
+}

package/packages/rust/cronixui/src/components/list.rs

@@ -0,0 +1,38 @@
+//! List component
+
+pub struct ListItem {
+    pub title: String,
+    pub subtitle: Option<String>,
+}
+
+impl ListItem {
+    pub fn new(title: impl Into<String>) -> Self {
+        Self { title: title.into(), subtitle: None }
+    }
+
+    pub fn subtitle(mut self, subtitle: impl Into<String>) -> Self {
+        self.subtitle = Some(subtitle.into());
+        self
+    }
+}
+
+pub struct List {
+    pub items: Vec<ListItem>,
+}
+
+impl List {
+    pub fn new() -> Self {
+        Self { items: Vec::new() }
+    }
+
+    pub fn item(mut self, item: ListItem) -> Self {
+        self.items.push(item);
+        self
+    }
+}
+
+impl Default for List {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/packages/rust/cronixui/src/components/mod.rs

@@ -0,0 +1,51 @@
+//! CronixUI Components for egui
+
+pub mod button;
+pub mod card;
+pub mod input;
+pub mod toggle;
+pub mod modal;
+pub mod tabs;
+pub mod accordion;
+pub mod toast;
+pub mod badge;
+pub mod avatar;
+pub mod progress;
+pub mod spinner;
+pub mod skeleton;
+pub mod table;
+pub mod list;
+pub mod nav;
+pub mod breadcrumb;
+pub mod tooltip;
+pub mod dropdown;
+pub mod pagination;
+pub mod file_input;
+pub mod search;
+pub mod command_palette;
+pub mod alert;
+
+pub use button::*;
+pub use card::*;
+pub use input::*;
+pub use toggle::*;
+pub use modal::*;
+pub use tabs::*;
+pub use accordion::*;
+pub use toast::*;
+pub use badge::*;
+pub use avatar::*;
+pub use progress::*;
+pub use spinner::*;
+pub use skeleton::*;
+pub use table::*;
+pub use list::*;
+pub use nav::*;
+pub use breadcrumb::*;
+pub use tooltip::*;
+pub use dropdown::*;
+pub use pagination::*;
+pub use file_input::*;
+pub use search::*;
+pub use command_palette::*;
+pub use alert::*;

package/packages/rust/cronixui/src/{modal.rs → components/modal.rs}

@@ -1,5 +1,9 @@
+//! Modal component
+
+use egui::Ui;
+
 pub struct Modal {
-    open: bool,
+    pub open: bool,
 }
 
 impl Modal {
@@ -18,6 +22,16 @@ impl Modal {
     pub fn is_open(&self) -> bool {
         self.open
     }
+
+    pub fn show<F: FnOnce(&mut Ui)>(&mut self, ui: &mut Ui, add_contents: F) {
+        if self.open {
+            egui::Area::new(egui::Id::new("modal"))
+                .interactable(true)
+                .show(ui.ctx(), |ui| {
+                    add_contents(ui);
+                });
+        }
+    }
 }
 
 impl Default for Modal {

package/packages/rust/cronixui/src/components/nav.rs

@@ -0,0 +1,19 @@
+//! Navigation component
+
+pub struct Nav {
+    pub items: Vec<String>,
+    pub active: usize,
+}
+
+impl Nav {
+    pub fn new(items: impl IntoIterator<Item = impl Into<String>>) -> Self {
+        Self {
+            items: items.into_iter().map(|s| s.into()).collect(),
+            active: 0,
+        }
+    }
+
+    pub fn set_active(&mut self, index: usize) {
+        self.active = index.min(self.items.len().saturating_sub(1));
+    }
+}

package/packages/rust/cronixui/src/{pagination.rs → components/pagination.rs}

@@ -1,12 +1,13 @@
+//! Pagination component
+
 pub struct Pagination {
-    total: usize,
-    current: usize,
+    pub total: usize,
+    pub current: usize,
 }
 
 impl Pagination {
-    pub fn new(total: usize, current: usize) -> Self {
-        let current = current.clamp(1, total.max(1));
-        Self { total, current }
+    pub fn new(total: usize) -> Self {
+        Self { total, current: 1 }
     }
 
     pub fn go_to(&mut self, page: usize) {
@@ -15,14 +16,6 @@ impl Pagination {
         }
     }
 
-    pub fn current(&self) -> usize {
-        self.current
-    }
-
-    pub fn total(&self) -> usize {
-        self.total
-    }
-
     pub fn next(&mut self) {
         if self.current < self.total {
             self.current += 1;
@@ -34,4 +27,12 @@ impl Pagination {
             self.current -= 1;
         }
     }
+
+    pub fn is_first(&self) -> bool {
+        self.current == 1
+    }
+
+    pub fn is_last(&self) -> bool {
+        self.current == self.total
+    }
 }

package/packages/rust/cronixui/src/components/progress.rs

@@ -0,0 +1,50 @@
+//! Progress component
+
+pub struct Progress {
+    pub value: f32,
+    pub max: f32,
+}
+
+impl Progress {
+    pub fn new() -> Self {
+        Self { value: 0.0, max: 100.0 }
+    }
+
+    pub fn set_value(&mut self, value: f32) {
+        self.value = value.clamp(0.0, self.max);
+    }
+
+    pub fn percentage(&self) -> f32 {
+        (self.value / self.max) * 100.0
+    }
+}
+
+impl Default for Progress {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub struct Stat {
+    pub value: String,
+    pub label: String,
+    pub delta: Option<String>,
+    pub delta_up: bool,
+}
+
+impl Stat {
+    pub fn new(value: impl Into<String>, label: impl Into<String>) -> Self {
+        Self {
+            value: value.into(),
+            label: label.into(),
+            delta: None,
+            delta_up: true,
+        }
+    }
+
+    pub fn delta(mut self, delta: impl Into<String>, up: bool) -> Self {
+        self.delta = Some(delta.into());
+        self.delta_up = up;
+        self
+    }
+}

package/packages/rust/cronixui/src/components/search.rs

@@ -0,0 +1,185 @@
+//! Search component
+
+use egui::*;
+use crate::{colors::*, tokens::*};
+
+pub struct SearchItem {
+    pub title: String,
+    pub subtitle: Option<String>,
+}
+
+impl SearchItem {
+    pub fn new(title: impl Into<String>) -> Self {
+        Self { title: title.into(), subtitle: None }
+    }
+
+    pub fn subtitle(mut self, subtitle: impl Into<String>) -> Self {
+        self.subtitle = Some(subtitle.into());
+        self
+    }
+}
+
+pub struct Search {
+    pub items: Vec<SearchItem>,
+    pub query: String,
+    id: Id,
+}
+
+impl Search {
+    pub fn new(id: impl Into<Id>) -> Self {
+        Self { items: Vec::new(), query: String::new(), id: id.into() }
+    }
+
+    pub fn item(mut self, item: SearchItem) -> Self {
+        self.items.push(item);
+        self
+    }
+
+    pub fn set_items(&mut self, items: Vec<SearchItem>) {
+        self.items = items;
+    }
+
+    pub fn filter(&self) -> Vec<&SearchItem> {
+        if self.query.is_empty() {
+            return self.items.iter().collect();
+        }
+        self.items
+            .iter()
+            .filter(|item| item.title.to_lowercase().contains(&self.query.to_lowercase()))
+            .collect()
+    }
+
+    /// Render the search UI with text input and results list
+    pub fn show(&mut self, ui: &mut Ui) -> Option<usize> {
+        let colors = Colors::default();
+        let mut selected = None;
+
+        // Search input field
+        ui.horizontal(|ui| {
+            ui.label("🔍");
+            let response = ui.add(
+                TextEdit::singleline(&mut self.query)
+                    .hint_text("Search...")
+                    .desired_width(f32::INFINITY)
+                    .font(FontId::new(tokens::FONT_SIZE_BASE, FontFamily::Proportional)),
+            );
+
+            if response.has_focus() {
+                // Show results dropdown when focused
+            }
+        });
+
+        // Results list
+        let results = self.filter();
+        if !results.is_empty() {
+            egui::Frame::none()
+                .fill(colors.surface)
+                .stroke(egui::Stroke::new(1.0, colors.border))
+                .rounding(Rounding::same(tokens::RADIUS))
+                .inner_margin(SPACE_2)
+                .show(ui, |ui| {
+                    for (idx, item) in results.iter().enumerate() {
+                        let response = ui.horizontal(|ui| {
+                            ui.label(
+                                RichText::new(&item.title)
+                                    .size(tokens::FONT_SIZE_BASE)
+                                    .color(colors.text),
+                            );
+                            if let Some(subtitle) = &item.subtitle {
+                                ui.label(
+                                    RichText::new(subtitle)
+                                        .size(tokens::FONT_SIZE_SM)
+                                        .color(colors.text_muted),
+                                );
+                            }
+                        });
+
+                        if response.response.clicked() {
+                            // Find original index
+                            if let Some(orig_idx) = self.items.iter().position(|i| std::ptr::eq(i, *item)) {
+                                selected = Some(orig_idx);
+                            }
+                        }
+                    }
+                });
+        } else if !self.query.is_empty() {
+            ui.label(
+                RichText::new("No results found")
+                    .size(tokens::FONT_SIZE_SM)
+                    .color(colors.text_muted),
+            );
+        }
+
+        selected
+    }
+}
+
+impl Default for Search {
+    fn default() -> Self {
+        Self::new("default_search")
+    }
+}
+
+/// Functional search helper
+pub fn search(ui: &mut Ui, query: &mut String, items: &[SearchItem]) -> Vec<&SearchItem> {
+    let colors = Colors::default();
+
+    ui.add(
+        TextEdit::singleline(query)
+            .hint_text("Search...")
+            .desired_width(f32::INFINITY),
+    );
+
+    if query.is_empty() {
+        return items.iter().collect();
+    }
+
+    items
+        .iter()
+        .filter(|item| item.title.to_lowercase().contains(&query.to_lowercase()))
+        .collect()
+}
+
+/// Render search results list
+pub fn search_results(ui: &mut Ui, results: &[&SearchItem]) -> Option<usize> {
+    let colors = Colors::default();
+    let mut clicked = None;
+
+    if !results.is_empty() {
+        egui::Frame::none()
+            .fill(colors.surface)
+            .stroke(egui::Stroke::new(1.0, colors.border))
+            .rounding(Rounding::same(tokens::RADIUS))
+            .inner_margin(SPACE_2)
+            .show(ui, |ui| {
+                for (idx, item) in results.iter().enumerate() {
+                    let response = ui.horizontal(|ui| {
+                        ui.label(
+                            RichText::new(&item.title)
+                                .size(tokens::FONT_SIZE_BASE)
+                                .color(colors.text),
+                        );
+                        if let Some(subtitle) = &item.subtitle {
+                            ui.label(
+                                RichText::new(subtitle)
+                                    .size(tokens::FONT_SIZE_SM)
+                                    .color(colors.text_muted),
+                            );
+                        }
+                    });
+
+                    if response.response.clicked() {
+                        clicked = Some(idx);
+                    }
+                }
+            });
+    } else {
+        ui.label(
+            RichText::new("No results found")
+                .size(tokens::FONT_SIZE_SM)
+                .color(colors.text_muted),
+        );
+    }
+
+    clicked
+}

package/packages/rust/cronixui/src/components/skeleton.rs

@@ -0,0 +1,63 @@
+//! Skeleton loading placeholder
+
+use egui::*;
+
+use crate::{colors::*, tokens::*};
+
+pub struct Skeleton {
+    pub width: f32,
+    pub height: f32,
+    pub variant: SkeletonVariant,
+}
+
+#[derive(Clone, Copy)]
+pub enum SkeletonVariant {
+    Text,
+    Title,
+    Avatar,
+    Block,
+}
+
+impl Skeleton {
+    pub fn text() -> Self {
+        Self { width: 100.0, height: 14.0, variant: SkeletonVariant::Text }
+    }
+
+    pub fn title() -> Self {
+        Self { width: 150.0, height: 20.0, variant: SkeletonVariant::Title }
+    }
+
+    pub fn avatar() -> Self {
+        Self { width: 40.0, height: 40.0, variant: SkeletonVariant::Avatar }
+    }
+
+    pub fn block(width: f32, height: f32) -> Self {
+        Self { width, height, variant: SkeletonVariant::Block }
+    }
+
+    pub fn width(mut self, width: f32) -> Self {
+        self.width = width;
+        self
+    }
+
+    pub fn height(mut self, height: f32) -> Self {
+        self.height = height;
+        self
+    }
+
+    pub fn show(&self, ui: &mut Ui) -> Response {
+        let colors = Colors::default();
+
+        let rounding = match self.variant {
+            SkeletonVariant::Avatar => Rounding::same(self.width / 2.0),
+            SkeletonVariant::Block => Rounding::same(tokens::RADIUS),
+            _ => Rounding::same(tokens::RADIUS_SM),
+        };
+
+        let (rect, response) = ui.allocate_at_least(vec2(self.width, self.height), Sense::hover());
+        ui.painter().rect_filled(rect, rounding, colors.surface_3);
+        ui.painter().rect_stroke(rect, rounding, Stroke::new(1.0, colors.border));
+
+        response
+    }
+}

package/packages/rust/cronixui/src/components/spinner.rs

@@ -0,0 +1,21 @@
+//! Spinner component
+
+use egui::{Color32, Ui};
+
+use crate::colors::ACCENT;
+
+pub fn spinner(ui: &mut Ui, size: f32) {
+    ui.add(egui::Spinner::new().size(size).color(ACCENT));
+}
+
+pub fn spinner_sm(ui: &mut Ui) {
+    spinner(ui, 16.0);
+}
+
+pub fn spinner_md(ui: &mut Ui) {
+    spinner(ui, 24.0);
+}
+
+pub fn spinner_lg(ui: &mut Ui) {
+    spinner(ui, 40.0);
+}

package/packages/rust/cronixui/src/components/table.rs

@@ -0,0 +1,56 @@
+//! Table component
+
+use egui::*;
+use crate::{colors::*, tokens::*};
+
+pub struct Table<'a> {
+    headers: Vec<&'a str>,
+    rows: Vec<Vec<String>>,
+}
+
+impl<'a> Table<'a> {
+    pub fn new(headers: impl IntoIterator<Item = &'a str>) -> Self {
+        Self { headers: headers.into_iter().collect(), rows: Vec::new() }
+    }
+
+    pub fn row(mut self, cells: impl IntoIterator<Item = impl Into<String>>) -> Self {
+        self.rows.push(cells.into_iter().map(|s| s.into()).collect());
+        self
+    }
+
+    pub fn show(&self, ui: &mut Ui) {
+        let colors = Colors::default();
+
+        // Render headers
+        ui.horizontal(|ui| {
+            for header in &self.headers {
+                egui::Frame::none()
+                    .fill(colors.surface_2)
+                    .stroke(egui::Stroke::new(1.0, colors.border))
+                    .rounding(Rounding::same(tokens::RADIUS_SM))
+                    .inner_margin(vec2(tokens::SPACE_2, tokens::SPACE_1))
+                    .show(ui, |ui| {
+                        ui.strong(*header);
+                    });
+            }
+        });
+
+        ui.add_space(tokens::SPACE_2);
+
+        // Render rows
+        for row in &self.rows {
+            ui.horizontal(|ui| {
+                for cell in row {
+                    egui::Frame::none()
+                        .fill(colors.surface)
+                        .stroke(egui::Stroke::new(1.0, colors.border))
+                        .rounding(Rounding::same(tokens::RADIUS_SM))
+                        .inner_margin(vec2(tokens::SPACE_2, tokens::SPACE_1))
+                        .show(ui, |ui| {
+                            ui.label(cell);
+                        });
+                }
+            });
+        }
+    }
+}

package/packages/rust/cronixui/src/components/tabs.rs

@@ -0,0 +1,43 @@
+//! Tabs component
+
+use egui::Ui;
+
+pub struct Tabs {
+    pub active: usize,
+}
+
+impl Tabs {
+    pub fn new() -> Self {
+        Self { active: 0 }
+    }
+
+    pub fn set_active(&mut self, index: usize) {
+        self.active = index;
+    }
+
+    pub fn active(&self) -> usize {
+        self.active
+    }
+
+    pub fn show(&mut self, ui: &mut Ui, labels: &[&str]) {
+        ui.horizontal(|ui| {
+            for (i, label) in labels.iter().enumerate() {
+                let is_active = i == self.active;
+                let text = if is_active {
+                    format!("▶ {}", label)
+                } else {
+                    label.to_string()
+                };
+                if ui.button(&text).clicked() {
+                    self.active = i;
+                }
+            }
+        });
+    }
+}
+
+impl Default for Tabs {
+    fn default() -> Self {
+        Self::new()
+    }
+}