cronixui 1.0.3 → 1.0.5

package/packages/python/cronixui/pagination.py

@@ -0,0 +1,58 @@
+"""Pagination component."""
+
+from typing import Callable, Optional
+
+
+class Pagination:
+    """Pagination component."""
+
+    def __init__(
+        self,
+        element=None,
+        total: int = 1,
+        current: int = 1,
+        on_change: Optional[Callable[[int], None]] = None,
+    ):
+        """Initialize pagination.
+
+        Args:
+            element: Target element
+            total: Total number of pages
+            current: Current page (default: 1)
+            on_change: Callback when page changes
+        """
+        self._element = element
+        self._total = total
+        self._current = current
+        self._on_change = on_change
+
+    def go_to(self, page: int) -> None:
+        """Go to specific page."""
+        if 1 <= page <= self._total:
+            self._current = page
+            if self._on_change:
+                self._on_change(page)
+
+    def next(self) -> None:
+        """Go to next page."""
+        if self._current < self._total:
+            self.go_to(self._current + 1)
+
+    def prev(self) -> None:
+        """Go to previous page."""
+        if self._current > 1:
+            self.go_to(self._current - 1)
+
+    @property
+    def current(self) -> int:
+        """Get current page."""
+        return self._current
+
+    @property
+    def total(self) -> int:
+        """Get total pages."""
+        return self._total
+
+    def render(self) -> None:
+        """Re-render pagination."""
+        pass

package/packages/python/cronixui/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "cronixui"
+version = "1.0.2"
+description = "CronixUI - A dark-themed UI toolkit with crimson accents and Outfit typography"
+license = {text = "GPL-3.0"}
+authors = [{name = "CazyUndee"}]
+keywords = ["ui", "dark-mode", "design-system", "components"]
+requires-python = ">=3.8"
+
+[project.urls]
+Repository = "https://github.com/CazyUndee/CronixUI"

package/packages/python/cronixui/search.py

@@ -0,0 +1,50 @@
+"""Search component."""
+
+from typing import Callable, Optional, List
+from dataclasses import dataclass
+
+
+@dataclass
+class SearchItem:
+    """Search result item."""
+
+    title: str
+    subtitle: Optional[str] = None
+    action: Optional[Callable] = None
+
+
+class Search:
+    """Search component."""
+
+    def __init__(self, element=None):
+        """Initialize search on element."""
+        self._element = element
+        self._items: List[SearchItem] = []
+        self._open: bool = False
+
+    def set_items(self, items: List[SearchItem]) -> None:
+        """Set searchable items."""
+        self._items = items
+
+    def filter(self, query: str) -> List[SearchItem]:
+        """Filter items by query."""
+        query_lower = query.lower()
+        return [item for item in self._items if query_lower in item.title.lower()]
+
+    def open(self) -> None:
+        """Open search results."""
+        self._open = True
+
+    def close(self) -> None:
+        """Close search results."""
+        self._open = False
+
+    def is_open(self) -> bool:
+        """Check if search is open."""
+        return self._open
+
+    def select(self, index: int) -> None:
+        """Select and execute item by index."""
+        if 0 <= index < len(self._items) and self._items[index].action:
+            self._items[index].action()
+            self.close()

package/packages/python/cronixui/tabs.py

@@ -0,0 +1,18 @@
+"""Tabs component."""
+
+
+class Tabs:
+    """Tabs component."""
+
+    def __init__(self, element=None):
+        """Initialize tabs on element."""
+        self._element = element
+        self._active_index: int = 0
+
+    def set_active(self, index: int) -> None:
+        """Set active tab by index."""
+        self._active_index = index
+
+    def active_index(self) -> int:
+        """Get active tab index."""
+        return self._active_index

package/packages/python/cronixui/toast.py

@@ -0,0 +1,73 @@
+"""Toast notification component."""
+
+from typing import Optional
+from enum import Enum
+
+
+class ToastType(Enum):
+    SUCCESS = "success"
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+
+
+class Toast:
+    """Toast notification component."""
+
+    def __init__(self, element=None):
+        self._element = element
+        self._title: Optional[str] = None
+        self._message: str = ""
+        self._type: ToastType = ToastType.INFO
+        self._duration: int = 4000
+
+    @staticmethod
+    def show(
+        title: Optional[str] = None,
+        message: str = "",
+        type: str = "info",
+        duration: int = 4000,
+    ) -> "Toast":
+        """Show a toast notification."""
+        toast = Toast()
+        toast._title = title
+        toast._message = message
+        toast._type = ToastType(type)
+        toast._duration = duration
+        return toast
+
+    @staticmethod
+    def success(message: str, title: Optional[str] = None) -> "Toast":
+        """Show a success toast."""
+        return Toast.show(title=title, message=message, type="success")
+
+    @staticmethod
+    def error(message: str, title: Optional[str] = None) -> "Toast":
+        """Show an error toast."""
+        return Toast.show(title=title, message=message, type="error")
+
+    @staticmethod
+    def warning(message: str, title: Optional[str] = None) -> "Toast":
+        """Show a warning toast."""
+        return Toast.show(title=title, message=message, type="warning")
+
+    @staticmethod
+    def info(message: str, title: Optional[str] = None) -> "Toast":
+        """Show an info toast."""
+        return Toast.show(title=title, message=message, type="info")
+
+    @property
+    def title(self) -> Optional[str]:
+        return self._title
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+    @property
+    def type(self) -> ToastType:
+        return self._type
+
+    @property
+    def duration(self) -> int:
+        return self._duration

package/packages/python/cronixui/toggle.py

@@ -0,0 +1,22 @@
+"""Toggle switch component."""
+
+
+class Toggle:
+    """Toggle switch component."""
+
+    def __init__(self, element=None):
+        """Initialize toggle on element."""
+        self._element = element
+        self._on: bool = False
+
+    def toggle(self) -> None:
+        """Toggle the state."""
+        self._on = not self._on
+
+    def is_on(self) -> bool:
+        """Check if toggle is on."""
+        return self._on
+
+    def set_on(self, value: bool) -> None:
+        """Set toggle state."""
+        self._on = value

package/packages/react/src/index.d.ts

@@ -0,0 +1,103 @@
+declare namespace CronixUI {
+  interface ToastOptions {
+    title?: string;
+    message: string;
+    type?: 'success' | 'error' | 'warning' | 'info';
+    duration?: number;
+  }
+
+  interface PaginationOptions {
+    total: number;
+    current: number;
+    onChange?: (page: number) => void;
+  }
+
+  interface SearchItem {
+    title: string;
+    subtitle?: string;
+    action: () => void;
+  }
+
+  interface CommandPaletteItem {
+    title: string;
+    kbd?: string;
+    action: () => void;
+  }
+
+  interface ModalInstance {
+    open(): void;
+    close(): void;
+  }
+
+  interface DropdownInstance {
+    open(): void;
+    close(): void;
+    toggle(): void;
+  }
+
+  interface ToggleInstance {
+    toggle(): void;
+    isOn(): boolean;
+    setOn(value: boolean): void;
+  }
+
+  interface TabsInstance {
+    setActive(index: number): void;
+  }
+
+  interface AccordionInstance {
+    toggle(item: HTMLElement): void;
+    openAll(): void;
+    closeAll(): void;
+  }
+
+  interface PaginationInstance {
+    goTo(page: number): void;
+    render(): void;
+  }
+
+  interface CommandPaletteInstance {
+    open(): void;
+    close(): void;
+    setItems(items: CommandPaletteItem[]): void;
+  }
+
+  interface SearchInstance {
+    setItems(items: SearchItem[]): void;
+    filter(query: string): SearchItem[];
+    open(): void;
+    close(): void;
+  }
+
+  interface ToastStatic {
+    show(options: ToastOptions): void;
+    success(message: string): void;
+    error(message: string): void;
+    warning(message: string): void;
+    info(message: string): void;
+  }
+
+  interface NavStatic {
+    init(): void;
+  }
+
+  interface CronixUIStatic {
+    init(): void;
+    $(selector: string): HTMLElement | null;
+    $$(selector: string): NodeListOf<HTMLElement>;
+    createEl(tag: string, className?: string, attrs?: Record<string, string>): HTMLElement;
+    Toast: ToastStatic;
+    Nav: NavStatic;
+    Toggle: new (element: HTMLElement) => ToggleInstance;
+    Modal: new (element: HTMLElement) => ModalInstance;
+    Dropdown: new (element: HTMLElement) => DropdownInstance;
+    Tabs: new (element: HTMLElement) => TabsInstance;
+    Accordion: new (element: HTMLElement) => AccordionInstance;
+    Pagination: new (element: HTMLElement, options: PaginationOptions) => PaginationInstance;
+    CommandPalette: new (element: HTMLElement) => CommandPaletteInstance;
+    Search: new (element: HTMLElement) => SearchInstance;
+  }
+}
+
+declare const CronixUI: CronixUI.CronixUIStatic;
+export default CronixUI;

package/packages/rust/cronixui/src/accordion.rs

@@ -0,0 +1,49 @@
+use std::collections::HashSet;
+
+pub struct Accordion {
+    open_indices: HashSet<usize>,
+}
+
+impl Accordion {
+    pub fn new() -> Self {
+        Self {
+            open_indices: HashSet::new(),
+        }
+    }
+
+    pub fn toggle(&mut self, index: usize) {
+        if self.open_indices.contains(&index) {
+            self.open_indices.remove(&index);
+        } else {
+            self.open_indices.insert(index);
+        }
+    }
+
+    pub fn open(&mut self, index: usize) {
+        self.open_indices.insert(index);
+    }
+
+    pub fn close(&mut self, index: usize) {
+        self.open_indices.remove(&index);
+    }
+
+    pub fn open_all(&mut self, total: usize) {
+        for i in 0..total {
+            self.open_indices.insert(i);
+        }
+    }
+
+    pub fn close_all(&mut self) {
+        self.open_indices.clear();
+    }
+
+    pub fn is_open(&self, index: usize) -> bool {
+        self.open_indices.contains(&index)
+    }
+}
+
+impl Default for Accordion {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/packages/rust/cronixui/src/command_palette.rs

@@ -0,0 +1,62 @@
+pub struct CommandPaletteItem {
+    pub title: String,
+    pub kbd: Option<String>,
+}
+
+impl CommandPaletteItem {
+    pub fn new(title: impl Into<String>) -> Self {
+        Self {
+            title: title.into(),
+            kbd: None,
+        }
+    }
+
+    pub fn kbd(mut self, kbd: impl Into<String>) -> Self {
+        self.kbd = Some(kbd.into());
+        self
+    }
+}
+
+pub struct CommandPalette {
+    open: bool,
+    items: Vec<CommandPaletteItem>,
+}
+
+impl CommandPalette {
+    pub fn new() -> Self {
+        Self {
+            open: false,
+            items: Vec::new(),
+        }
+    }
+
+    pub fn open(&mut self) {
+        self.open = true;
+    }
+
+    pub fn close(&mut self) {
+        self.open = false;
+    }
+
+    pub fn toggle(&mut self) {
+        self.open = !self.open;
+    }
+
+    pub fn is_open(&self) -> bool {
+        self.open
+    }
+
+    pub fn set_items(&mut self, items: Vec<CommandPaletteItem>) {
+        self.items = items;
+    }
+
+    pub fn items(&self) -> &[CommandPaletteItem] {
+        &self.items
+    }
+}
+
+impl Default for CommandPalette {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/packages/rust/cronixui/src/dropdown.rs

@@ -0,0 +1,31 @@
+pub struct Dropdown {
+    open: bool,
+}
+
+impl Dropdown {
+    pub fn new() -> Self {
+        Self { open: false }
+    }
+
+    pub fn open(&mut self) {
+        self.open = true;
+    }
+
+    pub fn close(&mut self) {
+        self.open = false;
+    }
+
+    pub fn toggle(&mut self) {
+        self.open = !self.open;
+    }
+
+    pub fn is_open(&self) -> bool {
+        self.open
+    }
+}
+
+impl Default for Dropdown {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/packages/rust/cronixui/src/lib.rs

@@ -0,0 +1,79 @@
+//! CronixUI - A dark-themed UI toolkit with crimson accents and Outfit typography
+//!
+//! ## Example
+//!
+//! ```rust
+//! use cronixui::{Toast, Toggle, Modal};
+//!
+//! // Create a toast
+//! let toast = Toast::success("Operation completed!");
+//!
+//! // Create a toggle
+//! let mut toggle = Toggle::new();
+//! toggle.toggle();
+//! assert!(toggle.is_on());
+//! ```
+
+pub const VERSION: &str = "1.0.4";
+
+mod toast;
+mod toggle;
+mod modal;
+mod dropdown;
+mod tabs;
+mod accordion;
+mod pagination;
+mod command_palette;
+mod search;
+
+pub use toast::{Toast, ToastType};
+pub use toggle::Toggle;
+pub use modal::Modal;
+pub use dropdown::Dropdown;
+pub use tabs::Tabs;
+pub use accordion::Accordion;
+pub use pagination::Pagination;
+pub use command_palette::{CommandPalette, CommandPaletteItem};
+pub use search::{Search, SearchItem};
+
+/// Initialize CronixUI
+pub fn init() {
+    println!("CronixUI {} initialized", VERSION);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_toggle() {
+        let mut toggle = Toggle::new();
+        assert!(!toggle.is_on());
+        toggle.toggle();
+        assert!(toggle.is_on());
+        toggle.set_on(false);
+        assert!(!toggle.is_on());
+    }
+
+    #[test]
+    fn test_pagination() {
+        let mut pagination = Pagination::new(10, 1);
+        assert_eq!(pagination.current(), 1);
+        pagination.next();
+        assert_eq!(pagination.current(), 2);
+        pagination.go_to(5);
+        assert_eq!(pagination.current(), 5);
+    }
+
+    #[test]
+    fn test_search() {
+        let mut search = Search::new();
+        search.set_items(vec![
+            SearchItem::new("Apple"),
+            SearchItem::new("Banana"),
+            SearchItem::new("Apricot"),
+        ]);
+        let results = search.filter("ap");
+        assert_eq!(results.len(), 2);
+    }
+}

package/packages/rust/cronixui/src/modal.rs

@@ -0,0 +1,27 @@
+pub struct Modal {
+    open: bool,
+}
+
+impl Modal {
+    pub fn new() -> Self {
+        Self { open: false }
+    }
+
+    pub fn open(&mut self) {
+        self.open = true;
+    }
+
+    pub fn close(&mut self) {
+        self.open = false;
+    }
+
+    pub fn is_open(&self) -> bool {
+        self.open
+    }
+}
+
+impl Default for Modal {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/packages/rust/cronixui/src/pagination.rs

@@ -0,0 +1,37 @@
+pub struct Pagination {
+    total: usize,
+    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 go_to(&mut self, page: usize) {
+        if page >= 1 && page <= self.total {
+            self.current = page;
+        }
+    }
+
+    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;
+        }
+    }
+
+    pub fn prev(&mut self) {
+        if self.current > 1 {
+            self.current -= 1;
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+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 {
+    items: Vec<SearchItem>,
+}
+
+impl Search {
+    pub fn new() -> Self {
+        Self { items: Vec::new() }
+    }
+
+    pub fn set_items(&mut self, items: Vec<SearchItem>) {
+        self.items = items;
+    }
+
+    pub fn filter(&self, query: &str) -> Vec<&SearchItem> {
+        self.items
+            .iter()
+            .filter(|item| item.title.to_lowercase().contains(&query.to_lowercase()))
+            .collect()
+    }
+
+    pub fn items(&self) -> &[SearchItem] {
+        &self.items
+    }
+}
+
+impl Default for Search {
+    fn default() -> Self {
+        Self::new()
+    }
+}

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

@@ -0,0 +1,23 @@
+pub struct Tabs {
+    active_index: usize,
+}
+
+impl Tabs {
+    pub fn new() -> Self {
+        Self { active_index: 0 }
+    }
+
+    pub fn set_active(&mut self, index: usize) {
+        self.active_index = index;
+    }
+
+    pub fn active_index(&self) -> usize {
+        self.active_index
+    }
+}
+
+impl Default for Tabs {
+    fn default() -> Self {
+        Self::new()
+    }
+}