cronixui 1.0.4 → 1.0.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cronixui",
-  "version": "1.0.4",
-  "description": "CronixUI - A dark-themed UI toolkit with crimson accents and Outfit typography",
+  "version": "1.0.5",
+  "description": "CronixUI - A dark-themed UI toolkit with crimson accents and Outfit typography. Available for JavaScript, TypeScript, Python, Go, and Rust.",
   "keywords": [
     "ui",
     "css",
@@ -40,6 +40,9 @@
     "packages/web/src/",
     "packages/react/src/",
     "packages/win/CronixUI.WinUI/",
+    "packages/python/cronixui/",
+    "packages/go/cronixui/",
+    "packages/rust/cronixui/src/",
     "README.md"
   ],
   "scripts": {

package/packages/go/cronixui/cronixui.go

@@ -0,0 +1,379 @@
+package cronixui
+
+import "fmt"
+
+// Version of CronixUI
+const Version = "1.0.4"
+
+// ToastType represents toast notification type
+type ToastType int
+
+const (
+	ToastTypeSuccess ToastType = iota
+	ToastTypeError
+	ToastTypeWarning
+	ToastTypeInfo
+)
+
+// Toast represents a toast notification
+type Toast struct {
+	Title    string
+	Message  string
+	Type     ToastType
+	Duration int
+}
+
+// ToastShow displays a toast notification
+func ToastShow(message string, opts ...func(*Toast)) *Toast {
+	t := &Toast{Message: message, Type: ToastTypeInfo, Duration: 4000}
+	for _, opt := range opts {
+		opt(t)
+	}
+	return t
+}
+
+// WithTitle sets toast title
+func WithTitle(title string) func(*Toast) {
+	return func(t *Toast) { t.Title = title }
+}
+
+// WithType sets toast type
+func WithType(toastType ToastType) func(*Toast) {
+	return func(t *Toast) { t.Type = toastType }
+}
+
+// WithDuration sets toast duration
+func WithDuration(duration int) func(*Toast) {
+	return func(t *Toast) { t.Duration = duration }
+}
+
+// ToastSuccess shows a success toast
+func ToastSuccess(message string) *Toast {
+	return ToastShow(message, WithType(ToastTypeSuccess))
+}
+
+// ToastError shows an error toast
+func ToastError(message string) *Toast {
+	return ToastShow(message, WithType(ToastTypeError))
+}
+
+// ToastWarning shows a warning toast
+func ToastWarning(message string) *Toast {
+	return ToastShow(message, WithType(ToastTypeWarning))
+}
+
+// ToastInfo shows an info toast
+func ToastInfo(message string) *Toast {
+	return ToastShow(message, WithType(ToastTypeInfo))
+}
+
+// Toggle represents a toggle switch
+type Toggle struct {
+	on bool
+}
+
+// NewToggle creates a new toggle
+func NewToggle() *Toggle {
+	return &Toggle{}
+}
+
+// Toggle flips the toggle state
+func (t *Toggle) Toggle() {
+	t.on = !t.on
+}
+
+// IsOn returns current toggle state
+func (t *Toggle) IsOn() bool {
+	return t.on
+}
+
+// SetOn sets the toggle state
+func (t *Toggle) SetOn(value bool) {
+	t.on = value
+}
+
+// Modal represents a modal dialog
+type Modal struct {
+	open bool
+}
+
+// NewModal creates a new modal
+func NewModal() *Modal {
+	return &Modal{}
+}
+
+// Open opens the modal
+func (m *Modal) Open() {
+	m.open = true
+}
+
+// Close closes the modal
+func (m *Modal) Close() {
+	m.open = false
+}
+
+// IsOpen returns whether modal is open
+func (m *Modal) IsOpen() bool {
+	return m.open
+}
+
+// Dropdown represents a dropdown menu
+type Dropdown struct {
+	open bool
+}
+
+// NewDropdown creates a new dropdown
+func NewDropdown() *Dropdown {
+	return &Dropdown{}
+}
+
+// Open opens the dropdown
+func (d *Dropdown) Open() {
+	d.open = true
+}
+
+// Close closes the dropdown
+func (d *Dropdown) Close() {
+	d.open = false
+}
+
+// Toggle flips dropdown state
+func (d *Dropdown) Toggle() {
+	d.open = !d.open
+}
+
+// IsOpen returns whether dropdown is open
+func (d *Dropdown) IsOpen() bool {
+	return d.open
+}
+
+// Tabs represents a tabs component
+type Tabs struct {
+	activeIndex int
+}
+
+// NewTabs creates new tabs
+func NewTabs() *Tabs {
+	return &Tabs{activeIndex: 0}
+}
+
+// SetActive sets active tab by index
+func (t *Tabs) SetActive(index int) {
+	t.activeIndex = index
+}
+
+// ActiveIndex returns current active index
+func (t *Tabs) ActiveIndex() int {
+	return t.activeIndex
+}
+
+// Accordion represents an accordion component
+type Accordion struct {
+	openIndices map[int]bool
+}
+
+// NewAccordion creates a new accordion
+func NewAccordion() *Accordion {
+	return &Accordion{openIndices: make(map[int]bool)}
+}
+
+// Toggle toggles an accordion item
+func (a *Accordion) Toggle(index int) {
+	a.openIndices[index] = !a.openIndices[index]
+}
+
+// Open opens an accordion item
+func (a *Accordion) Open(index int) {
+	a.openIndices[index] = true
+}
+
+// Close closes an accordion item
+func (a *Accordion) Close(index int) {
+	a.openIndices[index] = false
+}
+
+// OpenAll opens all items up to total
+func (a *Accordion) OpenAll(total int) {
+	for i := 0; i < total; i++ {
+		a.openIndices[i] = true
+	}
+}
+
+// CloseAll closes all accordion items
+func (a *Accordion) CloseAll() {
+	a.openIndices = make(map[int]bool)
+}
+
+// IsOpen returns whether item is open
+func (a *Accordion) IsOpen(index int) bool {
+	return a.openIndices[index]
+}
+
+// Pagination represents a pagination component
+type Pagination struct {
+	total   int
+	current int
+}
+
+// NewPagination creates new pagination
+func NewPagination(total, current int) *Pagination {
+	if current < 1 {
+		current = 1
+	}
+	if current > total {
+		current = total
+	}
+	return &Pagination{total: total, current: current}
+}
+
+// GoTo navigates to a specific page
+func (p *Pagination) GoTo(page int) {
+	if page >= 1 && page <= p.total {
+		p.current = page
+	}
+}
+
+// Next goes to next page
+func (p *Pagination) Next() {
+	if p.current < p.total {
+		p.current++
+	}
+}
+
+// Prev goes to previous page
+func (p *Pagination) Prev() {
+	if p.current > 1 {
+		p.current--
+	}
+}
+
+// Current returns current page
+func (p *Pagination) Current() int {
+	return p.current
+}
+
+// Total returns total pages
+func (p *Pagination) Total() int {
+	return p.total
+}
+
+// CommandPaletteItem represents a command palette item
+type CommandPaletteItem struct {
+	Title  string
+	Kbd    string
+	Action func()
+}
+
+// CommandPalette represents a command palette
+type CommandPalette struct {
+	open  bool
+	items []CommandPaletteItem
+}
+
+// NewCommandPalette creates a new command palette
+func NewCommandPalette() *CommandPalette {
+	return &CommandPalette{items: make([]CommandPaletteItem, 0)}
+}
+
+// Open opens command palette
+func (c *CommandPalette) Open() {
+	c.open = true
+}
+
+// Close closes command palette
+func (c *CommandPalette) Close() {
+	c.open = false
+}
+
+// Toggle toggles command palette
+func (c *CommandPalette) Toggle() {
+	c.open = !c.open
+}
+
+// IsOpen returns whether command palette is open
+func (c *CommandPalette) IsOpen() bool {
+	return c.open
+}
+
+// SetItems sets command items
+func (c *CommandPalette) SetItems(items []CommandPaletteItem) {
+	c.items = items
+}
+
+// Items returns all items
+func (c *CommandPalette) Items() []CommandPaletteItem {
+	return c.items
+}
+
+// Execute executes item by index
+func (c *CommandPalette) Execute(index int) {
+	if index >= 0 && index < len(c.items) && c.items[index].Action != nil {
+		c.items[index].Action()
+		c.Close()
+	}
+}
+
+// SearchItem represents a search result item
+type SearchItem struct {
+	Title    string
+	Subtitle string
+	Action   func()
+}
+
+// Search represents a search component
+type Search struct {
+	open  bool
+	items []SearchItem
+}
+
+// NewSearch creates a new search
+func NewSearch() *Search {
+	return &Search{items: make([]SearchItem, 0)}
+}
+
+// SetItems sets searchable items
+func (s *Search) SetItems(items []SearchItem) {
+	s.items = items
+}
+
+// Filter filters items by query
+func (s *Search) Filter(query string) []SearchItem {
+	var results []SearchItem
+	for _, item := range s.items {
+		results = append(results, item)
+	}
+	return results
+}
+
+// Open opens search results
+func (s *Search) Open() {
+	s.open = true
+}
+
+// Close closes search results
+func (s *Search) Close() {
+	s.open = false
+}
+
+// IsOpen returns whether search is open
+func (s *Search) IsOpen() bool {
+	return s.open
+}
+
+// Items returns all items
+func (s *Search) Items() []SearchItem {
+	return s.items
+}
+
+// Select selects and executes item by index
+func (s *Search) Select(index int) {
+	if index >= 0 && index < len(s.items) && s.items[index].Action != nil {
+		s.items[index].Action()
+		s.Close()
+	}
+}
+
+// Init initializes all CronixUI components
+func Init() {
+	fmt.Println("CronixUI", Version, "initialized")
+}

package/packages/go/cronixui/go.mod

@@ -0,0 +1,10 @@
+[package]
+name = "cronixui"
+version = "1.0.2"
+description = "CronixUI - A dark-themed UI toolkit with crimson accents and Outfit typography"
+license = "GPL-3.0"
+authors = ["CazyUndee"]
+keywords = ["ui", "dark-mode", "design-system", "components"]
+
+[lib]
+path = "cronixui.go"

package/packages/python/cronixui/__init__.py

@@ -0,0 +1,35 @@
+"""
+CronixUI - A dark-themed UI toolkit with crimson accents and Outfit typography
+"""
+
+from .toast import Toast
+from .toggle import Toggle
+from .modal import Modal
+from .dropdown import Dropdown
+from .tabs import Tabs
+from .accordion import Accordion
+from .pagination import Pagination
+from .command_palette import CommandPalette, CommandPaletteItem
+from .search import Search, SearchItem
+from .nav import Nav
+from .core import init, query, query_all, create_el
+
+__version__ = "1.0.4"
+__all__ = [
+    "Toast",
+    "Toggle",
+    "Modal",
+    "Dropdown",
+    "Tabs",
+    "Accordion",
+    "Pagination",
+    "CommandPalette",
+    "CommandPaletteItem",
+    "Search",
+    "SearchItem",
+    "Nav",
+    "init",
+    "query",
+    "query_all",
+    "create_el",
+]

package/packages/python/cronixui/accordion.py

@@ -0,0 +1,29 @@
+"""Accordion component."""
+
+
+class Accordion:
+    """Accordion component."""
+
+    def __init__(self, element=None):
+        """Initialize accordion on element."""
+        self._element = element
+        self._open_indices: list = []
+
+    def toggle(self, index: int) -> None:
+        """Toggle accordion item by index."""
+        if index in self._open_indices:
+            self._open_indices.remove(index)
+        else:
+            self._open_indices.append(index)
+
+    def open_all(self, total: int) -> None:
+        """Open all accordion items."""
+        self._open_indices = list(range(total))
+
+    def close_all(self) -> None:
+        """Close all accordion items."""
+        self._open_indices.clear()
+
+    def is_open(self, index: int) -> bool:
+        """Check if item is open."""
+        return index in self._open_indices

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

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

@@ -0,0 +1,70 @@
+use std::fmt;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ToastType {
+    Success,
+    Error,
+    Warning,
+    Info,
+}
+
+impl fmt::Display for ToastType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ToastType::Success => write!(f, "success"),
+            ToastType::Error => write!(f, "error"),
+            ToastType::Warning => write!(f, "warning"),
+            ToastType::Info => write!(f, "info"),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Toast {
+    pub title: Option<String>,
+    pub message: String,
+    pub toast_type: ToastType,
+    pub duration: u32,
+}
+
+impl Toast {
+    pub fn show(message: impl Into<String>) -> Self {
+        Self {
+            title: None,
+            message: message.into(),
+            toast_type: ToastType::Info,
+            duration: 4000,
+        }
+    }
+
+    pub fn title(mut self, title: impl Into<String>) -> Self {
+        self.title = Some(title.into());
+        self
+    }
+
+    pub fn toast_type(mut self, toast_type: ToastType) -> Self {
+        self.toast_type = toast_type;
+        self
+    }
+
+    pub fn duration(mut self, duration: u32) -> Self {
+        self.duration = duration;
+        self
+    }
+
+    pub fn success(message: impl Into<String>) -> Self {
+        Self::show(message).toast_type(ToastType::Success)
+    }
+
+    pub fn error(message: impl Into<String>) -> Self {
+        Self::show(message).toast_type(ToastType::Error)
+    }
+
+    pub fn warning(message: impl Into<String>) -> Self {
+        Self::show(message).toast_type(ToastType::Warning)
+    }
+
+    pub fn info(message: impl Into<String>) -> Self {
+        Self::show(message).toast_type(ToastType::Info)
+    }
+}

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

@@ -0,0 +1,27 @@
+pub struct Toggle {
+    on: bool,
+}
+
+impl Toggle {
+    pub fn new() -> Self {
+        Self { on: false }
+    }
+
+    pub fn toggle(&mut self) {
+        self.on = !self.on;
+    }
+
+    pub fn is_on(&self) -> bool {
+        self.on
+    }
+
+    pub fn set_on(&mut self, value: bool) {
+        self.on = value;
+    }
+}
+
+impl Default for Toggle {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/packages/web/src/index.js

@@ -0,0 +1,2 @@
+export { default as CronixUI } from './cronixui.js';
+export * from './cronixui.js';

package/packages/web/src/index.mjs

@@ -0,0 +1,2 @@
+export { default as CronixUI } from './cronixui.js';
+export * from './cronixui.js';