cronixui 1.0.4 → 1.0.6

package/packages/python/cronixui/command_palette.py

@@ -0,0 +1,53 @@
+"""Command palette component."""
+
+from typing import Callable, Optional, List
+from dataclasses import dataclass
+
+
+@dataclass
+class CommandPaletteItem:
+    """Command palette item."""
+
+    title: str
+    kbd: Optional[str] = None
+    action: Optional[Callable] = None
+
+
+class CommandPalette:
+    """Command palette component."""
+
+    def __init__(self, element=None):
+        """Initialize command palette on element."""
+        self._element = element
+        self._items: List[CommandPaletteItem] = []
+        self._open: bool = False
+
+    def open(self) -> None:
+        """Open command palette."""
+        self._open = True
+
+    def close(self) -> None:
+        """Close command palette."""
+        self._open = False
+
+    def toggle(self) -> None:
+        """Toggle command palette."""
+        self._open = not self._open
+
+    def is_open(self) -> bool:
+        """Check if command palette is open."""
+        return self._open
+
+    def set_items(self, items: List[CommandPaletteItem]) -> None:
+        """Set command items."""
+        self._items = items
+
+    def get_items(self) -> List[CommandPaletteItem]:
+        """Get all items."""
+        return self._items
+
+    def execute(self, index: int) -> None:
+        """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/core.py

@@ -0,0 +1,48 @@
+"""Core CronixUI functions."""
+
+from typing import Dict, Optional, List, Any
+
+
+def init() -> None:
+    """Initialize all CronixUI components."""
+    pass
+
+
+def query(selector: str) -> Optional[Any]:
+    """Query single element.
+
+    Args:
+        selector: CSS selector
+
+    Returns:
+        Element or None
+    """
+    pass
+
+
+def query_all(selector: str) -> List[Any]:
+    """Query all matching elements.
+
+    Args:
+        selector: CSS selector
+
+    Returns:
+        List of elements
+    """
+    return []
+
+
+def create_el(
+    tag: str, class_name: Optional[str] = None, attrs: Optional[Dict[str, str]] = None
+) -> Any:
+    """Create an element.
+
+    Args:
+        tag: HTML tag name
+        class_name: Optional CSS class name
+        attrs: Optional attributes dict
+
+    Returns:
+        Created element
+    """
+    pass

package/packages/python/cronixui/dropdown.py

@@ -0,0 +1,26 @@
+"""Dropdown menu component."""
+
+
+class Dropdown:
+    """Dropdown menu component."""
+
+    def __init__(self, element=None):
+        """Initialize dropdown on element."""
+        self._element = element
+        self._open: bool = False
+
+    def open(self) -> None:
+        """Open the dropdown."""
+        self._open = True
+
+    def close(self) -> None:
+        """Close the dropdown."""
+        self._open = False
+
+    def toggle(self) -> None:
+        """Toggle the dropdown."""
+        self._open = not self._open
+
+    def is_open(self) -> bool:
+        """Check if dropdown is open."""
+        return self._open

package/packages/python/cronixui/modal.py

@@ -0,0 +1,22 @@
+"""Modal dialog component."""
+
+
+class Modal:
+    """Modal dialog component."""
+
+    def __init__(self, element=None):
+        """Initialize modal on element."""
+        self._element = element
+        self._open: bool = False
+
+    def open(self) -> None:
+        """Open the modal."""
+        self._open = True
+
+    def close(self) -> None:
+        """Close the modal."""
+        self._open = False
+
+    def is_open(self) -> bool:
+        """Check if modal is open."""
+        return self._open

package/packages/python/cronixui/nav.py

@@ -0,0 +1,31 @@
+"""Navigation component."""
+
+
+class Nav:
+    """Navigation component."""
+
+    _instances = []
+
+    def __init__(self, element=None):
+        """Initialize navigation on element."""
+        self._element = element
+        self._active: str = ""
+        Nav._instances.append(self)
+
+    def set_active(self, item: str) -> None:
+        """Set active navigation item."""
+        self._active = item
+
+    def get_active(self) -> str:
+        """Get active navigation item."""
+        return self._active
+
+    @classmethod
+    def init(cls) -> None:
+        """Initialize all navigation components."""
+        pass
+
+    @classmethod
+    def get_all(cls) -> list:
+        """Get all navigation instances."""
+        return cls._instances

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/python/cronixui/tokens.py

@@ -0,0 +1,200 @@
+"""
+CronixUI Design Tokens
+"""
+
+from dataclasses import dataclass
+from typing import Tuple
+
+
+@dataclass(frozen=True)
+class Color:
+    """Color token."""
+
+    hex: str
+    rgb: Tuple[int, int, int]
+
+
+# Background colors
+BG = Color("#0a0a0a", (10, 10, 10))
+SURFACE = Color("#111111", (17, 17, 17))
+SURFACE_2 = Color("#1a1a1a", (26, 26, 26))
+SURFACE_3 = Color("#222222", (34, 34, 34))
+SURFACE_4 = Color("#2a2a2a", (42, 42, 42))
+
+# Text colors
+TEXT = Color("#f0ede8", (240, 237, 232))
+TEXT_MUTED = "rgba(240, 237, 232, 0.5)"
+TEXT_DIM = "rgba(240, 237, 232, 0.25)"
+
+# Accent (Crimson)
+ACCENT = Color("#6b2323", (107, 35, 35))
+ACCENT_HOVER = Color("#7d2a2a", (125, 42, 42))
+ACCENT_LIGHT = Color("#8a3535", (138, 53, 53))
+ACCENT_GLOW = "rgba(107, 35, 35, 0.3)"
+ACCENT_TEXT = Color("#c97a7a", (201, 122, 122))
+
+# Semantic colors
+SUCCESS = Color("#1e5028", (30, 80, 40))
+SUCCESS_BORDER = "rgba(60, 140, 70, 0.4)"
+SUCCESS_TEXT = Color("#6bc47a", (107, 196, 122))
+
+WARNING = Color("#503c14", (80, 60, 20))
+WARNING_BORDER = "rgba(150, 110, 30, 0.4)"
+WARNING_TEXT = Color("#c4a43a", (196, 164, 58))
+
+ERROR = Color("#501414", (80, 20, 20))
+ERROR_BORDER = "rgba(180, 60, 60, 0.4)"
+ERROR_TEXT = Color("#c46b6b", (196, 107, 107))
+
+INFO = Color("#143550", (20, 53, 80))
+INFO_BORDER = "rgba(60, 140, 200, 0.4)"
+INFO_TEXT = Color("#6ba8c4", (107, 168, 196))
+
+# Border
+BORDER = "rgba(255, 255, 255, 0.08)"
+BORDER_HOVER = "rgba(255, 255, 255, 0.15)"
+BORDER_FOCUS = "rgba(255, 255, 255, 0.25)"
+
+
+@dataclass(frozen=True)
+class Typography:
+    """Typography tokens."""
+
+    font_family: str = (
+        "'Outfit', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif"
+    )
+    font_mono: str = "'JetBrains Mono', 'Fira Code', 'Consolas', monospace"
+
+    # Font sizes
+    xs: int = 11
+    sm: int = 12
+    base: int = 13
+    md: int = 14
+    lg: int = 16
+    xl: int = 20
+    xxl: int = 28
+    xxxl: int = 36
+
+
+@dataclass(frozen=True)
+class Spacing:
+    """Spacing tokens."""
+
+    space_1: int = 4
+    space_2: int = 8
+    space_3: int = 12
+    space_4: int = 16
+    space_5: int = 20
+    space_6: int = 24
+    space_8: int = 32
+    space_10: int = 40
+    space_12: int = 48
+
+
+@dataclass(frozen=True)
+class Radius:
+    """Border radius tokens."""
+
+    sm: int = 6
+    default: int = 10
+    lg: int = 14
+    xl: int = 20
+    full: int = 9999
+
+
+@dataclass(frozen=True)
+class Shadow:
+    """Shadow tokens."""
+
+    sm: str = "0 1px 2px rgba(0, 0, 0, 0.3)"
+    default: str = "0 4px 12px rgba(0, 0, 0, 0.4)"
+    lg: str = "0 8px 24px rgba(0, 0, 0, 0.5)"
+    glow: str = "0 0 20px rgba(107, 35, 35, 0.3)"
+
+
+@dataclass(frozen=True)
+class Transition:
+    """Transition tokens."""
+
+    fast: str = "0.1s ease"
+    default: str = "0.15s ease"
+    slow: str = "0.25s ease"
+
+
+@dataclass(frozen=True)
+class ZIndex:
+    """Z-index tokens."""
+
+    dropdown: int = 100
+    sticky: int = 200
+    fixed: int = 300
+    modal_backdrop: int = 400
+    modal: int = 500
+    popover: int = 600
+    tooltip: int = 700
+    toast: int = 800
+
+
+@dataclass(frozen=True)
+class Layout:
+    """Layout tokens."""
+
+    container_max: int = 1200
+    sidebar_width: int = 260
+
+
+# Token instances
+typography = Typography()
+spacing = Spacing()
+radius = Radius()
+shadow = Shadow()
+transition = Transition()
+z_index = ZIndex()
+layout = Layout()
+
+
+__all__ = [
+    "Color",
+    "BG",
+    "SURFACE",
+    "SURFACE_2",
+    "SURFACE_3",
+    "SURFACE_4",
+    "TEXT",
+    "TEXT_MUTED",
+    "TEXT_DIM",
+    "ACCENT",
+    "ACCENT_HOVER",
+    "ACCENT_LIGHT",
+    "ACCENT_GLOW",
+    "ACCENT_TEXT",
+    "SUCCESS",
+    "SUCCESS_BORDER",
+    "SUCCESS_TEXT",
+    "WARNING",
+    "WARNING_BORDER",
+    "WARNING_TEXT",
+    "ERROR",
+    "ERROR_BORDER",
+    "ERROR_TEXT",
+    "INFO",
+    "INFO_BORDER",
+    "INFO_TEXT",
+    "BORDER",
+    "BORDER_HOVER",
+    "BORDER_FOCUS",
+    "Typography",
+    "typography",
+    "Spacing",
+    "spacing",
+    "Radius",
+    "radius",
+    "Shadow",
+    "shadow",
+    "Transition",
+    "transition",
+    "ZIndex",
+    "z_index",
+    "Layout",
+    "layout",
+]

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()
+    }
+}