eidosui 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

eidos/utils.py

@@ -0,0 +1,72 @@
+"""Core utility functions for EidosUI."""
+
+from typing import Optional, Union, List
+import os
+import sys
+
+
+def stringify(*classes: Optional[Union[str, List[str]]]) -> str:
+    """
+    Concatenate CSS classes, filtering out None values and flattening lists.
+    
+    Args:
+        *classes: Variable number of class strings, lists of strings, or None values
+        
+    Returns:
+        A single space-separated string of CSS classes
+        
+    Examples:
+        >>> stringify("btn", "btn-primary")
+        "btn btn-primary"
+        
+        >>> stringify("btn", None, "btn-lg")
+        "btn btn-lg"
+        
+        >>> stringify(["btn", "btn-primary"], "mt-4")
+        "btn btn-primary mt-4"
+    """
+    result = []
+    
+    for class_ in classes:
+        if class_ is None:
+            continue
+        elif isinstance(class_, list):
+            # Recursively handle lists
+            result.extend(c for c in class_ if c)
+        elif isinstance(class_, str) and class_.strip():
+            result.append(class_.strip())
+    
+    return " ".join(result)
+
+
+def get_eidos_static_directory() -> str:
+    """
+    Get the path to eidos static files for mounting in FastAPI/Air apps.
+    
+    This function returns the directory containing the eidos package files,
+    which includes the CSS directory. Use this when mounting static files
+    in your application.
+    
+    Returns:
+        The absolute path to the eidos package directory
+        
+    Example:
+        >>> from fastapi.staticfiles import StaticFiles
+        >>> from eidos.utils import get_eidos_static_directory
+        >>> app.mount("/eidos", StaticFiles(directory=get_eidos_static_directory()), name="eidos")
+    """
+    try:
+        from importlib.resources import files
+        import pathlib
+        # Convert MultiplexedPath to actual filesystem path
+        eidos_path = files('eidos')
+        if hasattr(eidos_path, '_paths'):
+            # MultiplexedPath - get the first valid path
+            for path in eidos_path._paths:
+                if isinstance(path, pathlib.Path) and path.exists():
+                    return str(path)
+        # Try to get the path directly
+        return str(eidos_path)
+    except (ImportError, AttributeError):
+        # Fallback for development or if importlib.resources fails
+        return os.path.dirname(os.path.abspath(__file__))

eidosui-0.3.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: eidosui
+Version: 0.3.0
+Summary: A modern, Tailwind CSS-based UI library for air development
+Project-URL: Homepage, https://github.com/isaac-flath/EidosUI
+Project-URL: Repository, https://github.com/isaac-flath/EidosUI
+Project-URL: Issues, https://github.com/isaac-flath/EidosUI/issues
+Project-URL: Documentation, https://github.com/isaac-flath/EidosUI#readme
+Author: Isaac Flath
+License-Expression: MIT
+License-File: LICENSE
+Keywords: air,components,css,fastapi,tailwind,ui,web
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: air>=0.12
+Requires-Dist: fastapi[standard]
+Requires-Dist: uvicorn
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: markdown
+Requires-Dist: markdown>=3.4; extra == 'markdown'
+Description-Content-Type: text/markdown
+
+# EidosUI 🎨
+
+A modern, flexible Tailwind CSS-based UI library for Python web frameworks. Built for maximum developer flexibility while providing excellent defaults.
+
+> [!CAUTION]
+> This library is not ready for anything yet.  IN fact, this readme is more of design ideas than anything as much of what's in here isn't implemented yet!
+
+
+## Design
+
+### Base CSS
+
+- `styles.css` : defines all the core css logic to create classes like `edios-mark`, `eidos-small`, etc.
+- `light.css`/`dark.css` : These define lots of css variables used in `styles.css` and are themes
+
+Users would create a custom theme by copying light/dark css files and changing the variable definitions.
+
+### Styles
+
+This has enums that make the Base CSS clases accessible in python.  For example:
+
+`styles.typography.h1` or `styles.buttons.primary`
+
+### Tags
+
+```python
+def H1(*content, cls: str = None, **kwargs) -> air.H1:
+    """Semantic H1 heading"""
+    return air.H1(*content, cls=stringify(styles.typography.h1, cls), **kwargs)
+
+def Mark(*content, cls: str = None, **kwargs) -> air.Mark:
+    """Highlighted text"""
+    return .Mark(*content, cls=stringify(styles.typography.mark, cls), **kwargs)
+
+def Small(*content, cls: str = , **kwargs) -> air.Small:
+    """Small text"""
+    return air.Small(*content, cls=stringify(styles.typography.small, cls), **kwargs) 
+```
+
+### Components (Not Built Yet)
+
+Theses are things that go beyond just exposing css to python.  Here's a simple example of what might be added.
+
+```python
+class Table:
+    def __init__(self, cls: str = None, **kwargs):
+        """Create an empty table with optional styling"""
+        self.cls = cls
+        self.kwargs = kwargs
+    
+    @classmethod
+    def from_lists(cls, data: list[list], headers: list[str] = None, cls_: str = None, **kwargs):
+        """Create table from list of lists"""
+        thead = []
+        if headers:
+            thead = THead(Tr(*[Th(header) for header in headers]))
+        
+        tbody_rows = []
+        for data in row_data:
+            tbody_rows.append(Tr(*map(Td, row_data)))
+        tbody = TBody(*tbody_rows)
+        
+        return Table(thead+tbody, cls=cls_, **kwargs)
+    
+    @classmethod
+    def from_dicts(cls, data: list[dict], headers: list[str] = None, cls_: str = None, **kwargs):
+        """Create table from list of dictionaries"""
+        thead = []
+        if headers:
+            thead = THead(Tr(*[Th(header) for header in headers]))
+        
+        tbody_rows = []
+        for row in data:
+            tbody_rows.append(Tr(*[Td(row.get(header, "")) for header in (headers or list(row.keys()))]))
+        tbody = TBody(*tbody_rows)
+        
+        return Table(thead+tbody, cls=cls_, **kwargs)
+
+# Usage examples:
+Table.from_lists([["A", "B"], ["C", "D"]], headers=["Col1", "Col2"])
+Table.from_dicts([{"name": "John", "age": 25}], headers=["Name", "Age"])
+```
+
+## Plugins
+
+### edios-md
+
+This will be installable with `pip install "eidos[markdown]"`. 
+
+This is a plugin for rendering markdown that is well scoped to just markdown rendering.  This module does markdown rendering well with table of contents with scrollspy, code highlighting, latex rendering, etc.  It must be used with `EidosUI` as it uses css variables from there for the styling (so it is always in sync with the theme)
+

eidosui-0.3.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+eidos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eidos/styles.py,sha256=QupOwC0VuSZ6zdNJiNFT_PqTnvbJvaNplKO5M5xzMVI,2380
+eidos/tags.py,sha256=2NidaD6JHDZ9nfSMXFKrG20eNc_u9K0t0t4xPdWJPUE,5966
+eidos/utils.py,sha256=DUw2a--J2rpZLY7YD3-xtHSmrK0YrnJuPi4rwV41zT8,2345
+eidos/components/headers.py,sha256=M4SZ_w_ius9cj7uRALo2niAkBz-iLYMVYAX8p556vyo,2005
+eidos/components/navigation.py,sha256=_8xQxVuZYmOIWk_85pa1L1ECYAXphIxV4iFmolNRwWQ,2515
+eidos/css/styles.css,sha256=KvrqNpdi7y0felLNhXwgys7cD4mbWjd5EzSqQWxjRgg,9770
+eidos/css/themes/dark.css,sha256=yUDNz7iLEJ_Q63MrKXlrhYcpojm1L2eNUOthzhYc3Vs,4170
+eidos/css/themes/eidos-variables.css,sha256=s4_CUivnqvndE4c7T1stp59orEHL_0C9tmN0rxai7bU,5686
+eidos/css/themes/light.css,sha256=kESbN5Z4ovCn-Q3fxilQcjafgMCIyyJiocU9kMC5sIM,2674
+eidos/js/eidos.js,sha256=ag6aoyWIE234ZoMiXJV-KVgBTsPR-fZd5Qhuo4rEeh0,5048
+eidos/plugins/__init__.py,sha256=Cv4nNAV74tOvyPyb2oEg7q2yhrHLC1lGwbWYjdT9Z4Y,25
+eidos/plugins/markdown/__init__.py,sha256=FuifCP1MmO0ACy7mq_kTwKLMnw8K15td_6E3Ihlrir4,555
+eidos/plugins/markdown/components.py,sha256=jz3yu4LIgBOTx0MS2o703al90jAquScmKehQQHV2dmY,1388
+eidos/plugins/markdown/renderer.py,sha256=NJYTJWgDySTUkrihYudLvRSR4hr6QeAqTpzZGN4eyo8,1971
+eidos/plugins/markdown/css/markdown.css,sha256=RxNx7aJDmJMx3zuydX10uAMaPFtl9r6zOFDni9Idsdk,6226
+eidos/plugins/markdown/extensions/__init__.py,sha256=wOdOyCcb-4lxEm77GMnJLst8JepecDcrN4sp3HO_q9A,28
+eidos/plugins/markdown/extensions/alerts.py,sha256=q1d49KyjPoTiK6OJ7gKvuwrFxM3BjPwssQnp6qhpFDs,4541
+eidosui-0.3.0.dist-info/METADATA,sha256=Dz7d3-Q3dAxHKOpJFD7YivKEukMDM4kQldJGYH5z7kE,4749
+eidosui-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+eidosui-0.3.0.dist-info/licenses/LICENSE,sha256=evjPJs6lg9eka9CYtC6ErQrZ71IovVbdvZqqz3ax8E8,1064
+eidosui-0.3.0.dist-info/RECORD,,

eidosui-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Feldroy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

eidos/components/__init__.py

@@ -1,22 +0,0 @@
-"""EidosUI Components - Simple MVP"""
-
-# Semantic Typography
-from .typography import (
-    H1, H2, H3, H4, H5, H6,
-    P, Text, Em, Strong, A,
-    Code, Pre, Mark, Small
-)
-
-# Forms
-from .forms import (
-    Button, Input, Textarea, Select, Label, FormGroup
-)
-
-__all__ = [
-    # Typography
-    "H1", "H2", "H3", "H4", "H5", "H6",
-    "P", "Text", "Em", "Strong", "A", 
-    "Code", "Pre", "Mark", "Small",
-    # Forms
-    "Button", "Input", "Textarea", "Select", "Label", "FormGroup",
-] 

eidos/components/forms.py

@@ -1,57 +0,0 @@
-"""Form components for EidosUI"""
-
-import fastapi_tags as ft
-from ..core.styles import button_styles, form_styles
-from ..core.utils import merge_classes
-
-
-def Button(*content, cls: str = button_styles.primary, size_cls: str = button_styles.md, **kwargs) -> ft.Button:
-    """Highly flexible button component that takes classes directly"""
-    return ft.Button(
-        *content,
-        cls=merge_classes(cls, size_cls),
-        **kwargs
-    )
-
-
-def Input(cls: str = form_styles.input, size_cls: str = "", state_cls: str = "", **kwargs) -> ft.Input:
-    """Flexible input component with class-based styling"""
-    return ft.Input(
-        cls=merge_classes(cls, size_cls, state_cls),
-        **kwargs
-    )
-
-
-def Textarea(cls: str = form_styles.textarea, **kwargs) -> ft.Textarea:
-    """Flexible textarea component"""
-    return ft.Textarea(
-        cls=cls,
-        **kwargs
-    )
-
-
-def Select(*options, cls: str = form_styles.select, **kwargs) -> ft.Select:
-    """Flexible select component"""
-    return ft.Select(
-        *options,
-        cls=cls,
-        **kwargs
-    )
-
-
-def Label(text: str, cls: str = form_styles.label, **kwargs) -> ft.Label:
-    """Flexible label component"""
-    return ft.Label(
-        text,
-        cls=cls,
-        **kwargs
-    )
-
-
-def FormGroup(*content, cls: str = form_styles.form_group, **kwargs) -> ft.Div:
-    """Form group container with default spacing"""
-    return ft.Div(
-        *content,
-        cls=cls,
-        **kwargs
-    ) 

eidos/components/typography.py

@@ -1,85 +0,0 @@
-"""Semantic typography components for EidosUI"""
-
-import fastapi_tags as ft
-from ..core.styles import typography_styles
-from ..core.utils import merge_classes
-
-
-def H1(*content, cls: str = typography_styles.h1, **kwargs) -> ft.H1:
-    """Semantic H1 heading"""
-    return ft.H1(*content, cls=cls, **kwargs)
-
-
-def H2(*content, cls: str = typography_styles.h2, **kwargs) -> ft.H2:
-    """Semantic H2 heading"""
-    return ft.H2(*content, cls=cls, **kwargs)
-
-
-def H3(*content, cls: str = typography_styles.h3, **kwargs) -> ft.H3:
-    """Semantic H3 heading"""
-    return ft.H3(*content, cls=cls, **kwargs)
-
-
-def H4(*content, cls: str = typography_styles.h4, **kwargs) -> ft.H4:
-    """Semantic H4 heading"""
-    return ft.H4(*content, cls=cls, **kwargs)
-
-
-def H5(*content, cls: str = typography_styles.h5, **kwargs) -> ft.H5:
-    """Semantic H5 heading"""
-    return ft.H5(*content, cls=cls, **kwargs)
-
-
-def H6(*content, cls: str = typography_styles.h6, **kwargs) -> ft.H6:
-    """Semantic H6 heading"""
-    return ft.H6(*content, cls=cls, **kwargs)
-
-
-def P(*content, cls: str = typography_styles.body, **kwargs) -> ft.P:
-    """Semantic paragraph"""
-    return ft.P(*content, cls=cls, **kwargs)
-
-
-def Text(*content, cls: str = typography_styles.body, **kwargs) -> ft.Span:
-    """Generic text span"""
-    return ft.Span(*content, cls=cls, **kwargs)
-
-
-def Em(*content, cls: str = typography_styles.em, **kwargs) -> ft.Em:
-    """Semantic emphasis (italic)"""
-    return ft.Em(*content, cls=cls, **kwargs)
-
-
-def Strong(*content, cls: str = typography_styles.strong, **kwargs) -> ft.Strong:
-    """Semantic strong emphasis (bold)"""
-    return ft.Strong(*content, cls=cls, **kwargs)
-
-
-def A(*content, href: str = "#", cls: str = typography_styles.link, **kwargs) -> ft.A:
-    """Semantic anchor link"""
-    return ft.A(*content, href=href, cls=cls, **kwargs)
-
-
-def Code(*content, cls: str = typography_styles.code, **kwargs) -> ft.Code:
-    """Inline code"""
-    return ft.Code(*content, cls=cls, **kwargs)
-
-
-def Pre(*content, cls: str = typography_styles.pre, **kwargs) -> ft.Pre:
-    """Preformatted text block"""
-    return ft.Pre(*content, cls=cls, **kwargs)
-
-
-# def Blockquote(*content, cls: str = typography_styles.blockquote, **kwargs) -> ft.Blockquote:
-#     """Semantic blockquote"""
-#     return ft.Blockquote(*content, cls=cls, **kwargs)
-
-
-def Mark(*content, cls: str = typography_styles.mark, **kwargs) -> ft.Mark:
-    """Highlighted text"""
-    return ft.Mark(*content, cls=cls, **kwargs)
-
-
-def Small(*content, cls: str = typography_styles.small, **kwargs) -> ft.Small:
-    """Small text"""
-    return ft.Small(*content, cls=cls, **kwargs) 

eidos/core/__init__.py

@@ -1,25 +0,0 @@
-"""Core functionality for EidosUI theme and style system"""
-
-from .styles import (
-    button_styles,
-    typography_styles,
-    form_styles,
-)
-from .utils import merge_classes
-from .helpers import (
-    serve_eidos_static,
-    create_eidos_head_tag,
-    get_theme_css,
-    get_eidos_js,
-)
-
-__all__ = [
-    "button_styles",
-    "typography_styles",
-    "form_styles",
-    "merge_classes",
-    "serve_eidos_static",
-    "create_eidos_head_tag",
-    "get_theme_css",
-    "get_eidos_js",
-] 

eidos/core/helpers.py

@@ -1,87 +0,0 @@
-"""Helper functions for easy EidosUI integration"""
-
-import importlib.resources
-from pathlib import Path
-from typing import Optional
-from fastapi import FastAPI
-from fastapi.staticfiles import StaticFiles
-
-
-def get_theme_css(theme: str = "light") -> str:
-    """Get CSS content for a theme directly from the package"""
-    try:
-        with importlib.resources.open_text("eidos.themes", f"{theme}.css") as f:
-            return f.read()
-    except FileNotFoundError:
-        return ""
-
-
-def get_eidos_js() -> str:
-    """Get JavaScript content directly from the package"""
-    try:
-        with importlib.resources.open_text("eidos.static", "eidos-ui.js") as f:
-            return f.read()
-    except FileNotFoundError:
-        return ""
-
-def serve_eidos_static(app: FastAPI, prefix: str = "/eidos") -> None:
-    """
-    Automatically mount EidosUI static files to a FastAPI app
-    
-    Args:
-        app: FastAPI application instance
-        prefix: URL prefix for static files (default: "/eidos")
-    """
-    try:
-        # Get the package directory paths
-        with importlib.resources.path("eidos", "static") as static_path:
-            app.mount(f"{prefix}/static", StaticFiles(directory=str(static_path)), name="eidos_static")
-        
-        with importlib.resources.path("eidos", "themes") as themes_path:
-            app.mount(f"{prefix}/themes", StaticFiles(directory=str(themes_path)), name="eidos_themes")
-            
-    except Exception as e:
-        # Fallback for development - try relative paths
-        import os
-        package_dir = Path(__file__).parent.parent
-        
-        if (package_dir / "static").exists():
-            app.mount(f"{prefix}/static", StaticFiles(directory=str(package_dir / "static")), name="eidos_static")
-        
-        if (package_dir / "themes").exists():
-            app.mount(f"{prefix}/themes", StaticFiles(directory=str(package_dir / "themes")), name="eidos_themes")
-
-
- 
-
-
-def create_eidos_head_tag(
-    title: str = "EidosUI App",
-    themes: list = ["light", "dark"],
-    prefix: str = "/eidos",
-    include_tailwind: bool = True
-):
-    """Create a fastapi-tags Head component with EidosUI setup"""
-    import fastapi_tags as ft
-    
-    head_content = []
-    
-    head_content.extend([
-        ft.Meta(charset="UTF-8"),
-        ft.Meta(name="viewport", content="width=device-width, initial-scale=1.0"),
-        ft.Title(title)
-    ])
-    
-    if include_tailwind:
-        head_content.append(ft.Script(src="https://cdn.tailwindcss.com"))
-    
-    # Add CSS links
-    for theme in themes:
-        head_content.append(ft.Link(rel="stylesheet", href=f"{prefix}/themes/{theme}.css"))
-    
-    # Add JS script
-    head_content.append(ft.Script(src=f"{prefix}/static/eidos-ui.js"))
-    
-    return ft.Head(*head_content)
-
-

eidos/core/styles.py

@@ -1,92 +0,0 @@
-"""Style dataclasses for EidosUI components using CSS variables"""
-
-from dataclasses import dataclass
-
-
-@dataclass(frozen=True)
-class ButtonStyles:
-    """Button style variations using CSS variables"""
-    
-    # Primary styles (most commonly used)
-    primary: str = "bg-[var(--color-primary)] hover:bg-[var(--color-primary-hover)] text-[var(--color-primary-foreground)] font-medium rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-primary)] focus:ring-offset-2 shadow-sm hover:shadow-md active:scale-95"
-    secondary: str = "bg-[var(--color-secondary)] hover:bg-[var(--color-secondary-hover)] text-[var(--color-secondary-foreground)] font-medium rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-secondary)] focus:ring-offset-2 shadow-sm hover:shadow-md active:scale-95"
-    ghost: str = "text-[var(--color-primary)] hover:bg-[var(--color-primary-light)] font-medium rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-primary)] focus:ring-offset-2 active:scale-95"
-    
-    # Semantic styles
-    success: str = "bg-[var(--color-success)] hover:bg-[var(--color-success-hover)] text-[var(--color-success-foreground)] font-medium rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-success)] focus:ring-offset-2 shadow-sm hover:shadow-md active:scale-95"
-    cta: str = "bg-[var(--color-cta)] hover:bg-[var(--color-cta-hover)] text-[var(--color-cta-foreground)] font-semibold rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-cta)] focus:ring-offset-2 shadow-md hover:shadow-lg active:scale-95 transform"
-    warning: str = "bg-[var(--color-warning)] hover:bg-[var(--color-warning-hover)] text-[var(--color-warning-foreground)] font-medium rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-warning)] focus:ring-offset-2 shadow-sm hover:shadow-md active:scale-95"
-    error: str = "bg-[var(--color-error)] hover:bg-[var(--color-error-hover)] text-[var(--color-error-foreground)] font-medium rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-error)] focus:ring-offset-2 shadow-sm hover:shadow-md active:scale-95"
-    info: str = "bg-[var(--color-info)] hover:bg-[var(--color-info-hover)] text-[var(--color-info-foreground)] font-medium rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-info)] focus:ring-offset-2 shadow-sm hover:shadow-md active:scale-95"
-    
-    # Size variations
-    sm: str = "px-3 py-1.5 text-sm"
-    md: str = "px-4 py-2 text-base"  # Default size
-    lg: str = "px-6 py-3 text-lg"
-    xl: str = "px-8 py-4 text-xl"
-    
-    # Icon styles
-    icon_sm: str = "p-1.5"
-    icon_md: str = "p-2"
-    icon_lg: str = "p-3"
-    
-    # Special styles
-    outline_primary: str = "border-2 border-[var(--color-primary)] text-[var(--color-primary)] hover:bg-[var(--color-primary)] hover:text-[var(--color-primary-foreground)] font-medium rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-primary)] focus:ring-offset-2 active:scale-95"
-    outline_secondary: str = "border-2 border-[var(--color-secondary)] text-[var(--color-secondary)] hover:bg-[var(--color-secondary)] hover:text-[var(--color-secondary-foreground)] font-medium rounded-lg transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-secondary)] focus:ring-offset-2 active:scale-95"
-    link: str = "text-[var(--color-primary)] hover:text-[var(--color-primary-hover)] underline-offset-4 hover:underline font-medium transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-[var(--color-primary)] focus:ring-offset-2 rounded active:scale-95"
-
-
-@dataclass(frozen=True) 
-class TypographyStyles:
-    """Typography style variations using CSS variables"""
-    
-    # Heading styles (mobile-first responsive)
-    h1: str = "text-2xl sm:text-3xl lg:text-4xl font-bold text-[var(--color-text)] leading-tight"
-    h2: str = "text-xl sm:text-2xl lg:text-3xl font-semibold text-[var(--color-text)] leading-tight"
-    h3: str = "text-lg sm:text-xl lg:text-2xl font-semibold text-[var(--color-text)] leading-tight"
-    h4: str = "text-base sm:text-lg lg:text-xl font-semibold text-[var(--color-text)] leading-tight"
-    h5: str = "text-sm sm:text-base lg:text-lg font-medium text-[var(--color-text)] leading-tight"
-    h6: str = "text-xs sm:text-sm lg:text-base font-medium text-[var(--color-text)] leading-tight"
-    
-    # Body text styles
-    body: str = "text-base text-[var(--color-text)] leading-relaxed"
-    
-    # Semantic emphasis
-    em: str = "italic"
-    strong: str = "font-semibold"
-    small: str = "text-sm text-[var(--color-text-muted)]"
-    
-    # Links
-    link: str = "text-[var(--color-primary)] hover:text-[var(--color-primary-hover)] underline underline-offset-2 transition-colors duration-200"
-    
-    # Text decorations
-    code: str = "font-mono bg-[var(--color-surface)] px-1.5 py-0.5 rounded text-sm"
-    pre: str = "bg-[var(--color-surface)] border border-[var(--color-border)] rounded-lg p-4 overflow-x-auto text-sm font-mono"
-    mark: str = "bg-[var(--color-warning-light)] px-1 rounded"
-    blockquote: str = "border-l-4 border-[var(--color-primary)] pl-6 py-2 italic text-[var(--color-text-muted)]"
-
-
-@dataclass(frozen=True)
-class FormStyles:
-    """Form component styles using CSS variables"""
-    
-    # Input styles
-    input: str = "w-full px-3 py-2 bg-[var(--color-input)] border border-[var(--color-border)] rounded-lg text-[var(--color-text)] placeholder:text-[var(--color-text-muted)] focus:outline-none focus:ring-2 focus:ring-[var(--color-primary)] focus:border-transparent transition-colors duration-200"
-    
-    # Textarea
-    textarea: str = "w-full px-3 py-2 bg-[var(--color-input)] border border-[var(--color-border)] rounded-lg text-[var(--color-text)] placeholder:text-[var(--color-text-muted)] focus:outline-none focus:ring-2 focus:ring-[var(--color-primary)] focus:border-transparent transition-colors duration-200 resize-y min-h-[80px]"
-    
-    # Select
-    select: str = "w-full px-3 py-2 bg-[var(--color-input)] border border-[var(--color-border)] rounded-lg text-[var(--color-text)] focus:outline-none focus:ring-2 focus:ring-[var(--color-primary)] focus:border-transparent transition-colors duration-200 appearance-none"
-    
-    # Labels
-    label: str = "block text-sm font-medium text-[var(--color-text)] mb-1"
-    
-    # Form groups
-    form_group: str = "space-y-2"
-
-
-# Global style instances for easy access
-button_styles = ButtonStyles()
-typography_styles = TypographyStyles()
-form_styles = FormStyles() 

eidos/core/utils.py

@@ -1,46 +0,0 @@
-"""Utility functions for EidosUI"""
-
-from typing import Union, Optional, List
-
-
-def merge_classes(*classes: Optional[Union[str, List[str]]]) -> str:
-    """
-    Merge multiple class strings, handling None values and lists
-    
-    Args:
-        *classes: Variable number of class strings, lists of strings, or None values
-        
-    Returns:
-        A single merged class string with duplicates removed and proper spacing
-        
-    Examples:
-        >>> merge_classes("text-base", "font-bold", None, "text-center")
-        "text-base font-bold text-center"
-        
-        >>> merge_classes(["bg-blue-500", "hover:bg-blue-600"], "rounded-lg")
-        "bg-blue-500 hover:bg-blue-600 rounded-lg"
-    """
-    result = []
-    
-    for cls in classes:
-        if cls is None:
-            continue
-        
-        if isinstance(cls, (list, tuple)):
-            # Handle lists/tuples of classes
-            for item in cls:
-                if item and isinstance(item, str):
-                    result.extend(item.split())
-        elif isinstance(cls, str) and cls.strip():
-            # Handle string classes
-            result.extend(cls.split())
-    
-    # Remove duplicates while preserving order
-    seen = set()
-    unique_classes = []
-    for class_name in result:
-        if class_name not in seen:
-            seen.add(class_name)
-            unique_classes.append(class_name)
-    
-    return ' '.join(unique_classes)