cronixui 1.0.3 → 1.0.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cronixui",
-  "version": "1.0.3",
-  "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",
@@ -19,11 +19,30 @@
   "main": "packages/web/dist/cronixui.js",
   "style": "packages/web/dist/cronixui.css",
   "types": "packages/web/src/cronixui.d.ts",
+  "exports": {
+    ".": {
+      "import": "./packages/web/dist/cronixui.js",
+      "require": "./packages/web/dist/cronixui.js",
+      "style": "./packages/web/dist/cronixui.css",
+      "types": "./packages/web/src/cronixui.d.ts"
+    },
+    "./react": {
+      "import": "./packages/react/src/index.js",
+      "types": "./packages/react/src/index.d.ts"
+    },
+    "./css": "./packages/web/dist/cronixui.css",
+    "./css/min": "./packages/web/dist/cronixui.min.css",
+    "./js": "./packages/web/dist/cronixui.js",
+    "./js/min": "./packages/web/dist/cronixui.min.js"
+  },
   "files": [
     "packages/web/dist/",
     "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