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

eidos/__init__.py

@@ -1,2 +0,0 @@
-from . import tags
-from . import styles

eidos/components/headers.py

@@ -1,5 +1,6 @@
-from air import Meta, Script, Link, Html, Head, Title
+from air import Meta, Script, Link
 from ..tags import Body
+from typing import Literal
 
 def get_css_urls():
     """Return list of CSS URLs for EidosUI."""
@@ -9,21 +10,59 @@ def get_css_urls():
         "/eidos/css/themes/light.css",
         "/eidos/css/themes/dark.css"
     ]
-def EidosHeaders(include_tailwind=True, theme="light"):
-    """Standard EidosUI headers with CSS includes."""
+
+def EidosHeaders(
+    include_tailwind: bool = True,
+    include_lucide: bool = True,
+    include_eidos_js: bool = True,
+    theme: Literal["light", "dark"] = "light",
+):
+    """Complete EidosUI headers with EidosUI JavaScript support.
+    
+    Args:
+        include_tailwind: Include Tailwind CSS CDN
+        include_lucide: Include Lucide Icons CDN
+        include_eidos_js: Include EidosUI JavaScript (navigation, future features)
+        theme: Initial theme
+    """
     headers = [
         Meta(charset="UTF-8"),
         Meta(name="viewport", content="width=device-width, initial-scale=1.0"),
     ]
     
+    # Core libraries
     if include_tailwind:
         headers.append(Script(src="https://cdn.tailwindcss.com"))
     
-    # Add EidosUI CSS files
+    if include_lucide:
+        headers.append(Script(src="https://unpkg.com/lucide@latest/dist/umd/lucide.js"))
+    
+    # EidosUI CSS
     for css_url in get_css_urls():
         headers.append(Link(rel="stylesheet", href=css_url))
     
-    # Set initial theme
-    headers.append(Script(f"document.documentElement.setAttribute('data-theme', '{theme}');"))
+    # EidosUI JavaScript
+    if include_eidos_js:
+        headers.append(Script(src="/eidos/js/eidos.js", defer=True))
+    
+    # Initialization script
+    init_script = f"""
+        // Set theme
+        document.documentElement.setAttribute('data-theme', '{theme}');
+    """
+    
+    if include_lucide:
+        init_script += """
+        // Initialize Lucide icons
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', () => {
+                if (window.lucide) lucide.createIcons();
+            });
+        } else {
+            if (window.lucide) lucide.createIcons();
+        }
+    """
+    
+    headers.append(Script(init_script))
     
     return headers

eidos/components/navigation.py

@@ -0,0 +1,78 @@
+from air import Div, A, I, Tag
+from ..tags import *
+from ..utils import stringify
+from typing import Final, Optional, Any, Union
+from uuid import uuid4
+
+class ScrollspyT:
+    underline: Final[str] = 'navbar-underline'
+    bold: Final[str] = 'navbar-bold'
+
+def NavBar(*c: Any,
+           lcontents: Tag = H3("Title"),
+           right_cls: str = 'items-center space-x-4',
+           mobile_cls: str = '',
+           sticky: bool = False,
+           scrollspy: bool = False,
+           cls: str = 'p-4',
+           scrollspy_cls: str = ScrollspyT.underline,
+           menu_id: Optional[str] = None,
+           ) -> Tag:
+    """Pure Tailwind responsive navigation bar with optional scrollspy.
+    
+    Mobile menu uses best practice dropdown with:
+    - Centered text links
+    - Large touch targets
+    - Auto-close on selection
+    - Smooth animations
+    """
+    if menu_id is None: menu_id = f"menu-{uuid4().hex[:8]}"
+    
+    sticky_cls = 'sticky top-0 eidos-navbar-sticky z-50' if sticky else ''
+    
+    # Mobile toggle button with hamburger/close icon
+    mobile_icon = A(
+        I(data_lucide="menu", class_="w-6 h-6", data_menu_icon="open"),
+        I(data_lucide="x", class_="w-6 h-6 hidden", data_menu_icon="close"),
+        class_="md:hidden cursor-pointer p-2 eidos-navbar-toggle rounded-lg transition-colors",
+        data_toggle=f"#{menu_id}",
+        role="button",
+        aria_label="Toggle navigation",
+        aria_expanded="false"
+    )
+    
+    # Desktop navigation
+    desktop_nav = Div(
+        *c,
+        class_=stringify(right_cls, 'hidden md:flex'),
+        data_scrollspy="true" if scrollspy else None
+    )
+    
+    # Mobile navigation
+    mobile_nav = Div(
+        *c,
+        class_=stringify(
+            mobile_cls, 
+            'hidden md:hidden absolute top-full left-0 right-0 eidos-navbar-mobile shadow-lg border-t',
+            'flex flex-col eidos-navbar-mobile-divider' if not mobile_cls else '',
+            scrollspy_cls
+        ),
+        id=menu_id,
+        data_scrollspy="true" if scrollspy else None,
+        data_mobile_menu="true"
+    )
+    
+    return Div(
+        # Main navbar container with relative positioning for mobile dropdown
+        Div(
+            Div(
+                lcontents,
+                mobile_icon,
+                desktop_nav,
+                class_='flex items-center justify-between'
+            ),
+            mobile_nav,
+            class_=stringify('eidos-navbar relative', cls, scrollspy_cls)
+        ),
+        class_=sticky_cls
+    )

eidos/css/styles.css

@@ -27,76 +27,79 @@
     transform: scale(0.98);
 }
 
-/* Primary Button */
-.eidos-btn-primary {
-    background-color: var(--color-primary);
-    color: var(--color-primary-foreground);
+/* Button Variants - Using CSS Custom Properties to reduce redundancy */
+.eidos-btn-primary,
+.eidos-btn-secondary,
+.eidos-btn-ghost,
+.eidos-btn-outline,
+.eidos-btn-success,
+.eidos-btn-error,
+.eidos-btn-cta {
+    background-color: var(--btn-bg, transparent);
+    color: var(--btn-color);
+    border: var(--btn-border, none);
 }
 
-.eidos-btn-primary:hover {
-    background-color: var(--color-primary-hover);
+.eidos-btn-primary:hover,
+.eidos-btn-secondary:hover,
+.eidos-btn-ghost:hover,
+.eidos-btn-outline:hover,
+.eidos-btn-success:hover,
+.eidos-btn-error:hover,
+.eidos-btn-cta:hover {
+    background-color: var(--btn-bg-hover);
+    color: var(--btn-color-hover, var(--btn-color));
 }
 
-/* Secondary Button */
-.eidos-btn-secondary {
-    background-color: var(--color-secondary-light);
-    color: var(--color-secondary-dark);
+/* Primary Button */
+.eidos-btn-primary {
+    --btn-bg: var(--color-primary);
+    --btn-color: var(--color-primary-foreground);
+    --btn-bg-hover: var(--color-primary-hover);
 }
 
-.eidos-btn-secondary:hover {
-    background-color: var(--color-border);
+/* Secondary Button */
+.eidos-btn-secondary {
+    --btn-bg: var(--color-secondary-light);
+    --btn-color: var(--color-secondary-dark);
+    --btn-bg-hover: var(--color-border);
 }
 
 /* Ghost Button */
 .eidos-btn-ghost {
-    background-color: transparent;
-    color: var(--color-secondary-dark);
-}
-
-.eidos-btn-ghost:hover {
-    background-color: rgba(0, 0, 0, var(--opacity-5));
+    --btn-bg: transparent;
+    --btn-color: var(--color-secondary-dark);
+    --btn-bg-hover: rgba(0, 0, 0, var(--opacity-5));
 }
 
 /* Outline Button */
 .eidos-btn-outline {
-    background-color: transparent;
-    border: var(--border-2) solid var(--color-primary);
-    color: var(--color-primary);
-}
-
-.eidos-btn-outline:hover {
-    background-color: var(--color-primary);
-    color: var(--color-primary-foreground);
+    --btn-bg: transparent;
+    --btn-border: var(--border-2) solid var(--color-primary);
+    --btn-color: var(--color-primary);
+    --btn-bg-hover: var(--color-primary);
+    --btn-color-hover: var(--color-primary-foreground);
 }
 
 /* Success Button */
 .eidos-btn-success {
-    background-color: var(--color-success);
-    color: var(--color-success-foreground);
-}
-
-.eidos-btn-success:hover {
-    background-color: var(--color-success-hover);
+    --btn-bg: var(--color-success);
+    --btn-color: var(--color-success-foreground);
+    --btn-bg-hover: var(--color-success-hover);
 }
 
 /* Error Button */
 .eidos-btn-error {
-    background-color: var(--color-error);
-    color: var(--color-error-foreground);
-}
-
-.eidos-btn-error:hover {
-    background-color: var(--color-error-hover);
+    --btn-bg: var(--color-error);
+    --btn-color: var(--color-error-foreground);
+    --btn-bg-hover: var(--color-error-hover);
 }
 
 /* CTA Button */
 .eidos-btn-cta {
-    background-color: var(--color-cta);
-    color: var(--color-cta-foreground);
-}
-
-.eidos-btn-cta:hover {
-    background-color: var(--color-cta-hover);
+    --btn-bg: var(--color-cta);
+    --btn-color: var(--color-cta-foreground);
+    --btn-bg-hover: var(--color-cta-hover);
 }
 
 .eidos-h1 {
@@ -335,3 +338,93 @@
     border-top: var(--border) solid var(--color-border);
     margin: var(--space-xl) 0;
 }
+
+/* Navigation base styles */
+.eidos-navbar {
+    width: 100%;
+}
+
+.eidos-navbar a {
+    padding: 0.5rem 0.75rem;
+    border-radius: 0.375rem;
+    font-size: 0.875rem;
+    font-weight: 500;
+    transition: all 0.2s ease;
+    position: relative;
+}
+
+.eidos-navbar a:hover {
+    background-color: var(--color-border);
+}
+
+/* Sticky navbar */
+.eidos-navbar-sticky {
+    background-color: var(--color-background);
+    box-shadow: var(--shadow-sm);
+}
+
+/* Mobile toggle button */
+.eidos-navbar-toggle:hover {
+    background-color: var(--color-border);
+}
+
+/* Mobile menu dropdown */
+.eidos-navbar-mobile {
+    background-color: var(--color-background);
+    border-color: var(--color-border);
+}
+
+/* Mobile menu dividers */
+.eidos-navbar-mobile-divider > a:not(:last-child) {
+    border-bottom: var(--border) solid var(--color-border);
+}
+
+/* Underline style */
+.navbar-underline a.eidos-active::after {
+    content: '';
+    position: absolute;
+    bottom: -2px;
+    left: 0;
+    right: 0;
+    height: 2px;
+    background-color: var(--color-primary);
+}
+
+/* Bold style */
+.navbar-bold a.eidos-active {
+    font-weight: 700;
+    color: var(--color-primary);
+}
+
+/* Mobile menu animation */
+[data-toggle] + * {
+    transition: all 0.3s ease;
+}
+
+/* Mobile navigation styles */
+[data-mobile-menu="true"] {
+    animation: slideDown 0.2s ease-out;
+}
+
+[data-mobile-menu="true"] a {
+    padding: 1rem 1.5rem;
+    text-align: center;
+    display: block;
+    font-weight: 500;
+    transition: all 0.2s ease;
+}
+
+[data-mobile-menu="true"] a:hover {
+    background-color: var(--color-border);
+}
+
+@keyframes slideDown {
+    from {
+        transform: translateY(-0.5rem);
+        opacity: 0;
+    }
+    to {
+        transform: translateY(0);
+        opacity: 1;
+    }
+}

eidos/js/eidos.js

@@ -0,0 +1,112 @@
+// eidos.js - Main EidosUI JavaScript file
+(function() {
+    'use strict';
+    
+    class EidosUI {
+        constructor() {
+            this.initToggle();
+            this.initScrollspy();
+        }
+        
+        initToggle() {
+            document.querySelectorAll('[data-toggle]').forEach(btn => {
+                btn.addEventListener('click', (e) => {
+                    e.preventDefault();
+                    const targetId = btn.dataset.toggle;
+                    const target = document.querySelector(targetId);
+                    if (target) {
+                        const isHidden = target.classList.contains('hidden');
+                        target.classList.toggle('hidden');
+                        
+                        // Update ARIA attributes
+                        const toggleButtons = document.querySelectorAll(`[data-toggle="${targetId}"][role="button"]`);
+                        toggleButtons.forEach(toggleBtn => {
+                            toggleBtn.setAttribute('aria-expanded', isHidden);
+                            
+                            // Toggle menu icons if they exist
+                            const openIcon = toggleBtn.querySelector('[data-menu-icon="open"]');
+                            const closeIcon = toggleBtn.querySelector('[data-menu-icon="close"]');
+                            if (openIcon && closeIcon) {
+                                openIcon.classList.toggle('hidden');
+                                closeIcon.classList.toggle('hidden');
+                            }
+                        });
+                    }
+                });
+            });
+            
+            // Auto-close mobile menu when clicking a link
+            document.querySelectorAll('[data-mobile-menu="true"] a').forEach(link => {
+                link.addEventListener('click', () => {
+                    const menu = link.closest('[data-mobile-menu="true"]');
+                    if (menu && !menu.classList.contains('hidden')) {
+                        menu.classList.add('hidden');
+                        // Update toggle button state
+                        const menuId = '#' + menu.id;
+                        const toggleBtn = document.querySelector(`[data-toggle="${menuId}"][role="button"]`);
+                        if (toggleBtn) {
+                            toggleBtn.setAttribute('aria-expanded', 'false');
+                            const openIcon = toggleBtn.querySelector('[data-menu-icon="open"]');
+                            const closeIcon = toggleBtn.querySelector('[data-menu-icon="close"]');
+                            if (openIcon && closeIcon) {
+                                openIcon.classList.remove('hidden');
+                                closeIcon.classList.add('hidden');
+                            }
+                        }
+                    }
+                });
+            });
+        }
+        
+        initScrollspy() {
+            const containers = document.querySelectorAll('[data-scrollspy="true"]');
+            if (!containers.length) return;
+            
+            const sections = document.querySelectorAll('section[id], [data-scrollspy-target]');
+            if (!sections.length) return;
+            
+            const observerOptions = {
+                rootMargin: '-20% 0px -70% 0px',
+                threshold: [0, 0.1, 0.5, 1]
+            };
+            
+            const observer = new IntersectionObserver((entries) => {
+                entries.forEach(entry => {
+                    if (entry.intersectionRatio > 0.1) {
+                        const id = entry.target.id;
+                        containers.forEach(container => {
+                            const links = container.querySelectorAll('a[href^="#"]');
+                            links.forEach(link => {
+                                const isActive = link.getAttribute('href') === `#${id}`;
+                                link.classList.toggle('eidos-active', isActive);
+                            });
+                        });
+                    }
+                });
+            }, observerOptions);
+            
+            sections.forEach(section => observer.observe(section));
+            
+            // Smooth scrolling for nav links
+            containers.forEach(container => {
+                container.querySelectorAll('a[href^="#"]').forEach(link => {
+                    link.addEventListener('click', (e) => {
+                        const targetId = link.getAttribute('href');
+                        const target = document.querySelector(targetId);
+                        if (target) {
+                            e.preventDefault();
+                            target.scrollIntoView({ behavior: 'smooth', block: 'start' });
+                        }
+                    });
+                });
+            });
+        }
+    }
+    
+    window.EidosUI = EidosUI;
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', () => new EidosUI());
+    } else {
+        new EidosUI();
+    }
+})();

eidos/plugins/__init__.py

@@ -0,0 +1 @@
+# EidosUI plugins package

eidos/plugins/markdown/__init__.py

@@ -0,0 +1,21 @@
+"""EidosUI Markdown Plugin - Theme-aware markdown rendering
+
+This plugin provides markdown rendering that automatically integrates with
+EidosUI themes through CSS variables.
+
+Basic usage:
+    from eidos.plugins.markdown import Markdown, MarkdownCSS
+    
+    # In your document head
+    MarkdownCSS()
+    
+    # In your content
+    Markdown("# Hello World\\n\\nThis is **markdown**!")
+"""
+
+from .components import Markdown, MarkdownCSS
+from .renderer import MarkdownRenderer
+
+__all__ = ["Markdown", "MarkdownCSS", "MarkdownRenderer"]
+
+__version__ = "0.1.0"

eidos/plugins/markdown/components.py

@@ -0,0 +1,53 @@
+"""Markdown components for EidosUI"""
+
+import air
+from typing import Optional
+from .renderer import MarkdownRenderer
+
+
+# Global renderer instance for reuse
+_renderer = MarkdownRenderer()
+
+
+def Markdown(content: str, class_: Optional[str] = None, **kwargs) -> air.Div:
+    """Main markdown component that renders markdown content with theme integration.
+    
+    Args:
+        content: Markdown text to render
+        class_: Additional CSS classes to apply
+        **kwargs: Additional attributes to pass to the wrapper div
+        
+    Returns:
+        air.Div containing the rendered markdown HTML
+    """
+    # Render the markdown content
+    html_content = _renderer.render(content)
+    
+    # Create the div with raw HTML content
+    if class_:
+        return air.Div(
+            air.RawHTML(html_content),
+            class_=class_,
+            **kwargs
+        )
+    else:
+        return air.Div(
+            air.RawHTML(html_content),
+            **kwargs
+        )
+
+
+def MarkdownCSS() -> air.Link:
+    """Returns a link tag to include the markdown CSS.
+    
+    This should be included in the head of your document to ensure
+    markdown styling is available.
+    
+    Returns:
+        air.Link element pointing to the markdown CSS file
+    """
+    return air.Link(
+        rel="stylesheet",
+        href="/eidos/plugins/markdown/css/markdown.css",
+        type="text/css"
+    )

eidos/plugins/markdown/css/markdown.css

@@ -0,0 +1,283 @@
+/* EidosUI Markdown Styles - Theme-aware markdown rendering */
+
+/* Base container */
+.eidos-md {
+    color: var(--color-text);
+    line-height: var(--line-height-relaxed);
+    font-size: var(--font-size-base);
+}
+
+/* Headings */
+.eidos-md h1 {
+    font-size: var(--font-size-4xl);
+    font-weight: var(--font-weight-bold);
+    color: var(--color-text);
+    margin-top: var(--space-2xl);
+    margin-bottom: var(--space-lg);
+    line-height: var(--line-height-tight);
+}
+
+.eidos-md h2 {
+    font-size: var(--font-size-3xl);
+    font-weight: var(--font-weight-semibold);
+    color: var(--color-text);
+    margin-top: var(--space-xl);
+    margin-bottom: var(--space-md);
+    line-height: var(--line-height-tight);
+}
+
+.eidos-md h3 {
+    font-size: var(--font-size-2xl);
+    font-weight: var(--font-weight-semibold);
+    color: var(--color-text);
+    margin-top: var(--space-lg);
+    margin-bottom: var(--space-md);
+    line-height: var(--line-height-snug);
+}
+
+.eidos-md h4 {
+    font-size: var(--font-size-xl);
+    font-weight: var(--font-weight-medium);
+    color: var(--color-text);
+    margin-top: var(--space-lg);
+    margin-bottom: var(--space-sm);
+    line-height: var(--line-height-snug);
+}
+
+.eidos-md h5 {
+    font-size: var(--font-size-lg);
+    font-weight: var(--font-weight-medium);
+    color: var(--color-text);
+    margin-top: var(--space-md);
+    margin-bottom: var(--space-sm);
+    line-height: var(--line-height-normal);
+}
+
+.eidos-md h6 {
+    font-size: var(--font-size-base);
+    font-weight: var(--font-weight-medium);
+    color: var(--color-text);
+    margin-top: var(--space-md);
+    margin-bottom: var(--space-sm);
+    line-height: var(--line-height-normal);
+}
+
+/* Paragraphs */
+.eidos-md p {
+    margin-top: 0;
+    margin-bottom: var(--space-md);
+}
+
+/* Links */
+.eidos-md a {
+    color: var(--color-primary);
+    text-decoration: underline;
+    text-underline-offset: 2px;
+    transition: color var(--transition-fast);
+}
+
+.eidos-md a:hover {
+    color: var(--color-primary-hover);
+}
+
+/* Lists */
+.eidos-md ul {
+    margin-top: 0;
+    margin-bottom: var(--space-md);
+    padding-left: var(--space-lg);
+    list-style-type: disc;
+}
+
+.eidos-md ol {
+    margin-top: 0;
+    margin-bottom: var(--space-md);
+    padding-left: var(--space-lg);
+    list-style-type: decimal;
+}
+
+.eidos-md li {
+    margin-bottom: var(--space-xs);
+}
+
+/* Nested lists */
+.eidos-md ul ul {
+    list-style-type: circle;
+    margin-top: var(--space-xs);
+    margin-bottom: 0;
+}
+
+.eidos-md ul ul ul {
+    list-style-type: square;
+}
+
+.eidos-md ol ol {
+    list-style-type: lower-alpha;
+    margin-top: var(--space-xs);
+    margin-bottom: 0;
+}
+
+.eidos-md ul ol,
+.eidos-md ol ul {
+    margin-top: var(--space-xs);
+    margin-bottom: 0;
+}
+
+/* Code */
+.eidos-md code {
+    background-color: var(--color-surface);
+    padding: calc(var(--space-xs) / 2) var(--space-xs);
+    border-radius: var(--radius-sm);
+    font-size: var(--font-size-sm);
+    font-family: ui-monospace, SFMono-Regular, "SF Mono", Consolas, "Liberation Mono", Menlo, monospace;
+}
+
+.eidos-md pre {
+    background-color: var(--color-surface);
+    border: var(--border) solid var(--color-border);
+    border-radius: var(--radius-md);
+    padding: var(--space-md);
+    overflow-x: auto;
+    margin-top: 0;
+    margin-bottom: var(--space-md);
+}
+
+.eidos-md pre code {
+    background-color: transparent;
+    padding: 0;
+    border-radius: 0;
+    font-size: var(--font-size-sm);
+}
+
+/* Blockquotes */
+.eidos-md blockquote {
+    border-left: var(--border-4) solid var(--color-primary);
+    padding-left: var(--space-md);
+    margin: var(--space-lg) 0;
+    color: var(--color-text-muted);
+}
+
+.eidos-md blockquote p:last-child {
+    margin-bottom: 0;
+}
+
+/* Tables */
+.eidos-md table {
+    width: 100%;
+    border-collapse: collapse;
+    margin: var(--space-lg) 0;
+    font-size: var(--font-size-sm);
+}
+
+.eidos-md th {
+    background-color: var(--color-surface);
+    font-weight: var(--font-weight-semibold);
+    padding: var(--space-sm) var(--space-md);
+    border-bottom: var(--border-2) solid var(--color-border);
+    text-align: left;
+}
+
+.eidos-md td {
+    padding: var(--space-sm) var(--space-md);
+    border-bottom: var(--border) solid var(--color-border);
+}
+
+.eidos-md tr:hover {
+    background-color: rgba(0, 0, 0, var(--opacity-5));
+}
+
+/* Horizontal rules */
+.eidos-md hr {
+    border: none;
+    border-top: var(--border) solid var(--color-border);
+    margin: var(--space-xl) 0;
+}
+
+/* Images */
+.eidos-md img {
+    max-width: 100%;
+    height: auto;
+    border-radius: var(--radius-md);
+    margin: var(--space-md) 0;
+}
+
+/* Strong and emphasis */
+.eidos-md strong {
+    font-weight: var(--font-weight-semibold);
+    color: var(--color-text);
+}
+
+.eidos-md em {
+    font-style: italic;
+}
+
+/* Definition lists */
+.eidos-md dl {
+    margin: var(--space-md) 0;
+}
+
+.eidos-md dt {
+    font-weight: var(--font-weight-semibold);
+    margin-top: var(--space-md);
+}
+
+.eidos-md dd {
+    margin-left: var(--space-lg);
+    margin-bottom: var(--space-sm);
+}
+
+/* GitHub-style Alerts */
+.eidos-alert {
+    padding: var(--space-md);
+    border-radius: var(--radius-md);
+    margin: var(--space-lg) 0;
+    border: var(--border) solid;
+}
+
+.eidos-alert-header {
+    display: flex;
+    align-items: center;
+    gap: var(--space-sm);
+    margin-bottom: var(--space-sm);
+    font-weight: var(--font-weight-semibold);
+}
+
+.eidos-alert-icon {
+    font-size: var(--font-size-lg);
+}
+
+.eidos-alert-title {
+    font-size: var(--font-size-base);
+}
+
+.eidos-alert-content {
+    margin-left: calc(var(--font-size-lg) + var(--space-sm));
+}
+
+.eidos-alert-content > *:last-child {
+    margin-bottom: 0;
+}
+
+/* Alert variants */
+.eidos-alert-info {
+    background-color: var(--color-info-light);
+    border-color: var(--color-info);
+    color: var(--color-info-dark);
+}
+
+.eidos-alert-success {
+    background-color: var(--color-success-light);
+    border-color: var(--color-success);
+    color: var(--color-success-dark);
+}
+
+.eidos-alert-warning {
+    background-color: var(--color-warning-light);
+    border-color: var(--color-warning);
+    color: var(--color-warning-dark);
+}
+
+.eidos-alert-error {
+    background-color: var(--color-error-light);
+    border-color: var(--color-error);
+    color: var(--color-error-dark);
+}

eidos/plugins/markdown/extensions/__init__.py

@@ -0,0 +1 @@
+# Markdown plugin extensions

eidos/plugins/markdown/extensions/alerts.py

@@ -0,0 +1,134 @@
+"""GitHub-style alerts extension for markdown"""
+
+import re
+from markdown.extensions import Extension
+from markdown.blockprocessors import BlockProcessor
+import xml.etree.ElementTree as etree
+from xml.etree.ElementTree import SubElement
+
+
+class AlertBlockProcessor(BlockProcessor):
+    """Process GitHub-style alert blocks"""
+    
+    # Pattern to match > [!TYPE] at the start of a blockquote
+    RE_ALERT = re.compile(r'^> \[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]', re.MULTILINE)
+    
+    # Alert type configurations
+    ALERT_TYPES = {
+        'NOTE': {
+            'class': 'eidos-alert eidos-alert-info',
+            'icon': 'ℹ️',
+            'title': 'Note'
+        },
+        'TIP': {
+            'class': 'eidos-alert eidos-alert-success',
+            'icon': '💡',
+            'title': 'Tip'
+        },
+        'IMPORTANT': {
+            'class': 'eidos-alert eidos-alert-warning',
+            'icon': '❗',
+            'title': 'Important'
+        },
+        'WARNING': {
+            'class': 'eidos-alert eidos-alert-warning',
+            'icon': '⚠️',
+            'title': 'Warning'
+        },
+        'CAUTION': {
+            'class': 'eidos-alert eidos-alert-error',
+            'icon': '🔴',
+            'title': 'Caution'
+        }
+    }
+    
+    def test(self, parent, block):
+        """Test if the block is a GitHub-style alert"""
+        return bool(self.RE_ALERT.match(block))
+    
+    def run(self, parent, blocks):
+        """Process the alert block"""
+        block = blocks.pop(0)
+        
+        # Extract alert type
+        match = self.RE_ALERT.match(block)
+        if not match:
+            return False
+            
+        alert_type = match.group(1)
+        alert_config = self.ALERT_TYPES.get(alert_type, self.ALERT_TYPES['NOTE'])
+        
+        # Create the alert container
+        alert_div = SubElement(parent, 'div')
+        alert_div.set('class', alert_config['class'])
+        
+        # Add the header with icon and title
+        header = SubElement(alert_div, 'div')
+        header.set('class', 'eidos-alert-header')
+        
+        icon_span = SubElement(header, 'span')
+        icon_span.set('class', 'eidos-alert-icon')
+        icon_span.text = alert_config['icon']
+        
+        title_span = SubElement(header, 'span')
+        title_span.set('class', 'eidos-alert-title')
+        title_span.text = alert_config['title']
+        
+        # Process the content
+        content_div = SubElement(alert_div, 'div')
+        content_div.set('class', 'eidos-alert-content')
+        
+        # Remove the alert marker and process the remaining content
+        content = self.RE_ALERT.sub('', block)
+        
+        # Handle multi-line content
+        lines = content.split('\n')
+        processed_lines = []
+        
+        for line in lines:
+            # Remove leading '>' from each line
+            if line.startswith('>'):
+                line = line[1:].lstrip()
+            processed_lines.append(line)
+        
+        # Join the content and parse it
+        content_text = '\n'.join(processed_lines).strip()
+        
+        # Parse the content as markdown
+        if content_text:
+            # Create a temporary element to hold parsed content
+            temp_element = etree.Element('div')
+            self.parser.parseBlocks(temp_element, [content_text])
+            
+            # Move all children to our content div
+            for child in temp_element:
+                content_div.append(child)
+            
+            # If no children were added, add the text directly
+            if len(content_div) == 0:
+                p = SubElement(content_div, 'p')
+                p.text = content_text
+        
+        # Continue processing subsequent blocks that might be part of the alert
+        while blocks and blocks[0].startswith('>'):
+            continuation = blocks.pop(0)
+            # Remove leading '>' and process
+            continuation_text = continuation[1:].lstrip() if continuation.startswith('>') else continuation
+            
+            if continuation_text:
+                p = SubElement(content_div, 'p')
+                p.text = continuation_text
+        
+        return True
+
+
+class AlertExtension(Extension):
+    """Add GitHub-style alerts to markdown"""
+    
+    def extendMarkdown(self, md):
+        """Add the alert processor to the markdown instance"""
+        md.parser.blockprocessors.register(
+            AlertBlockProcessor(md.parser),
+            'github_alerts',
+            175  # Priority - process before blockquote
+        )

eidos/plugins/markdown/renderer.py

@@ -0,0 +1,58 @@
+"""Core markdown rendering with theme integration"""
+
+import markdown
+from typing import Optional, List, Union
+from .extensions.alerts import AlertExtension
+
+
+class MarkdownRenderer:
+    """Core markdown rendering with theme integration"""
+    
+    def __init__(self, extensions: Optional[List[Union[str, markdown.Extension]]] = None):
+        """Initialize the renderer with optional extensions.
+        
+        Args:
+            extensions: List of markdown extension names or instances to enable
+        """
+        self.extensions = extensions or []
+        # Add some useful default extensions
+        default_extensions = [
+            'fenced_code', 
+            'tables', 
+            'nl2br', 
+            'sane_lists',
+            AlertExtension()  # Add GitHub-style alerts
+        ]
+        self.extensions.extend(default_extensions)
+        
+        # Initialize the markdown processor
+        self.md = markdown.Markdown(extensions=self.extensions)
+    
+    def render(self, markdown_text: str) -> str:
+        """Convert markdown to themed HTML.
+        
+        Args:
+            markdown_text: Raw markdown text to render
+            
+        Returns:
+            HTML string wrapped with eidos-md class for styling
+        """
+        # Reset the markdown processor to clear any state
+        self.md.reset()
+        
+        # Convert markdown to HTML
+        html_content = self.md.convert(markdown_text)
+        
+        # Wrap in a div with our markdown class for styling
+        return f'<div class="eidos-md">{html_content}</div>'
+    
+    def add_extension(self, extension: str) -> None:
+        """Add a markdown extension.
+        
+        Args:
+            extension: Name of the markdown extension to add
+        """
+        if extension not in self.extensions:
+            self.extensions.append(extension)
+            # Recreate the markdown processor with new extensions
+            self.md = markdown.Markdown(extensions=self.extensions)

eidos/tags.py

@@ -1,99 +1,99 @@
-from typing import Optional, Literal
+from typing import Optional, Literal, Any, Union
 import air
 from . import styles
 from .utils import stringify
 
-def Button(*content, cls = styles.buttons.primary, **kwargs):
-    return air.Button(*content, cls=stringify(styles.buttons.base, cls), **kwargs)
+def Button(*content: Any, class_: Optional[Union[str, list[str]]] = styles.buttons.primary, **kwargs: Any) -> air.Tag:
+    return air.Button(*content, class_=stringify(styles.buttons.base, class_), **kwargs)
 
-def H1(*content, cls = None, **kwargs):
-    return air.H1(*content, cls=stringify(styles.typography.h1, cls), **kwargs)
+def H1(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.H1(*content, class_=stringify(styles.typography.h1, class_), **kwargs)
 
-def H2(*content, cls = None, **kwargs):
-    return air.H2(*content, cls=stringify(styles.typography.h2, cls), **kwargs)
+def H2(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.H2(*content, class_=stringify(styles.typography.h2, class_), **kwargs)
 
-def H3(*content, cls = None, **kwargs):
-    return air.H3(*content, cls=stringify(styles.typography.h3, cls), **kwargs)
+def H3(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.H3(*content, class_=stringify(styles.typography.h3, class_), **kwargs)
 
-def H4(*content, cls = None, **kwargs):
-    return air.H4(*content, cls=stringify(styles.typography.h4, cls), **kwargs)
+def H4(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.H4(*content, class_=stringify(styles.typography.h4, class_), **kwargs)
 
-def H5(*content, cls = None, **kwargs):
-    return air.H5(*content, cls=stringify(styles.typography.h5, cls), **kwargs)
+def H5(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.H5(*content, class_=stringify(styles.typography.h5, class_), **kwargs)
 
-def H6(*content, cls = None, **kwargs):
-    return air.H6(*content, cls=stringify(styles.typography.h6, cls), **kwargs)
+def H6(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.H6(*content, class_=stringify(styles.typography.h6, class_), **kwargs)
 
-def Body(*content, cls = None, **kwargs):
-    return air.Body(*content, cls=stringify(styles.Theme.body, cls), **kwargs)
+def Body(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Body(*content, class_=stringify(styles.Theme.body, class_), **kwargs)
 
 # Semantic HTML Elements
 
-def Strong(*content, cls = None, **kwargs):
-    return air.Strong(*content, cls=stringify(styles.semantic.strong, cls), **kwargs)
+def Strong(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Strong(*content, class_=stringify(styles.semantic.strong, class_), **kwargs)
 
-def I(*content, cls = None, **kwargs):
-    return air.I(*content, cls=stringify(styles.semantic.i, cls), **kwargs)
+def I(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.I(*content, class_=stringify(styles.semantic.i, class_), **kwargs)
 
-def Small(*content, cls = None, **kwargs):
-    return air.Small(*content, cls=stringify(styles.semantic.small, cls), **kwargs)
+def Small(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Small(*content, class_=stringify(styles.semantic.small, class_), **kwargs)
 
-def Del(*content, cls = None, **kwargs):
-    return air.Del(*content, cls=stringify(styles.semantic.del_, cls), **kwargs)
+def Del(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Del(*content, class_=stringify(styles.semantic.del_, class_), **kwargs)
 
-def Abbr(*content, cls = None, **kwargs):
-    return air.Abbr(*content, cls=stringify(styles.semantic.abbr, cls), **kwargs)
+def Abbr(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Abbr(*content, class_=stringify(styles.semantic.abbr, class_), **kwargs)
 
-def Var(*content, cls = None, **kwargs):
-    return air.Var(*content, cls=stringify(styles.semantic.var, cls), **kwargs)
+def Var(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Var(*content, class_=stringify(styles.semantic.var, class_), **kwargs)
 
-def Mark(*content, cls = None, **kwargs):
-    return air.Mark(*content, cls=stringify(styles.semantic.mark, cls), **kwargs)
+def Mark(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Mark(*content, class_=stringify(styles.semantic.mark, class_), **kwargs)
 
-def Time(*content, cls = None, **kwargs):
-    return air.Time(*content, cls=stringify(styles.semantic.time, cls), **kwargs)
+def Time(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Time(*content, class_=stringify(styles.semantic.time, class_), **kwargs)
 
-def Code(*content, cls = None, **kwargs):
-    return air.Code(*content, cls=stringify(styles.semantic.code, cls), **kwargs)
+def Code(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Code(*content, class_=stringify(styles.semantic.code, class_), **kwargs)
 
-def Pre(*content, cls = None, **kwargs):
-    return air.Pre(*content, cls=stringify(styles.semantic.pre, cls), **kwargs)
+def Pre(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Pre(*content, class_=stringify(styles.semantic.pre, class_), **kwargs)
 
-def Kbd(*content, cls = None, **kwargs):
-    return air.Kbd(*content, cls=stringify(styles.semantic.kbd, cls), **kwargs)
+def Kbd(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Kbd(*content, class_=stringify(styles.semantic.kbd, class_), **kwargs)
 
-def Samp(*content, cls = None, **kwargs):
-    return air.Samp(*content, cls=stringify(styles.semantic.samp, cls), **kwargs)
+def Samp(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Samp(*content, class_=stringify(styles.semantic.samp, class_), **kwargs)
 
-def Blockquote(*content, cls = None, **kwargs):
-    return air.Blockquote(*content, cls=stringify(styles.semantic.blockquote, cls), **kwargs)
+def Blockquote(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Blockquote(*content, class_=stringify(styles.semantic.blockquote, class_), **kwargs)
 
-def Cite(*content, cls = None, **kwargs):
-    return air.Cite(*content, cls=stringify(styles.semantic.cite, cls), **kwargs)
+def Cite(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Cite(*content, class_=stringify(styles.semantic.cite, class_), **kwargs)
 
-def Address(*content, cls = None, **kwargs):
-    return air.Address(*content, cls=stringify(styles.semantic.address, cls), **kwargs)
+def Address(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Address(*content, class_=stringify(styles.semantic.address, class_), **kwargs)
 
-def Hr(cls = None, **kwargs):
-    return air.Hr(cls=stringify(styles.semantic.hr, cls), **kwargs)
+def Hr(class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Hr(class_=stringify(styles.semantic.hr, class_), **kwargs)
 
-def Details(*content, cls = None, **kwargs):
-    return air.Details(*content, cls=stringify(styles.semantic.details, cls), **kwargs)
+def Details(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Details(*content, class_=stringify(styles.semantic.details, class_), **kwargs)
 
-def Summary(*content, cls = None, **kwargs):
-    return air.Summary(*content, cls=stringify(styles.semantic.summary, cls), **kwargs)
+def Summary(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Summary(*content, class_=stringify(styles.semantic.summary, class_), **kwargs)
 
-def Dl(*content, cls = None, **kwargs):
-    return air.Dl(*content, cls=stringify(styles.semantic.dl, cls), **kwargs)
+def Dl(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Dl(*content, class_=stringify(styles.semantic.dl, class_), **kwargs)
 
-def Dt(*content, cls = None, **kwargs):
-    return air.Dt(*content, cls=cls, **kwargs)
+def Dt(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Dt(*content, class_=stringify(styles.semantic.dt, class_), **kwargs)
 
-def Dd(*content, cls = None, **kwargs):
-    return air.Dd(*content, cls=stringify(styles.semantic.dd, cls), **kwargs)
+def Dd(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Dd(*content, class_=stringify(styles.semantic.dd, class_), **kwargs)
 
-def Figure(*content, cls = None, **kwargs):
-    return air.Figure(*content, cls=stringify(styles.semantic.figure, cls), **kwargs)
+def Figure(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Figure(*content, class_=stringify(styles.semantic.figure, class_), **kwargs)
 
-def Figcaption(*content, cls = None, **kwargs):
-    return air.Figcaption(*content, cls=stringify(styles.semantic.figcaption, cls), **kwargs)
+def Figcaption(*content: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Figcaption(*content, class_=stringify(styles.semantic.figcaption, class_), **kwargs)

eidos/utils.py

@@ -27,14 +27,14 @@ def stringify(*classes: Optional[Union[str, List[str]]]) -> str:
     """
     result = []
     
-    for cls in classes:
-        if cls is None:
+    for class_ in classes:
+        if class_ is None:
             continue
-        elif isinstance(cls, list):
+        elif isinstance(class_, list):
             # Recursively handle lists
-            result.extend(c for c in cls if c)
-        elif isinstance(cls, str) and cls.strip():
-            result.append(cls.strip())
+            result.extend(c for c in class_ if c)
+        elif isinstance(class_, str) and class_.strip():
+            result.append(class_.strip())
     
     return " ".join(result)
 
@@ -57,7 +57,16 @@ def get_eidos_static_directory() -> str:
     """
     try:
         from importlib.resources import files
-        return str(files('eidos'))
+        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.2.0.dist-info → eidosui-0.3.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: eidosui
-Version: 0.2.0
-Summary: A modern, Tailwind CSS-based UI library for Python web frameworks
+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
@@ -9,7 +9,7 @@ Project-URL: Documentation, https://github.com/isaac-flath/EidosUI#readme
 Author: Isaac Flath
 License-Expression: MIT
 License-File: LICENSE
-Keywords: components,css,fastapi,tailwind,ui,web
+Keywords: air,components,css,fastapi,tailwind,ui,web
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -17,11 +17,12 @@ 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
-Requires-Dist: fastapi
+Requires-Dist: air>=0.12
+Requires-Dist: fastapi[standard]
 Requires-Dist: uvicorn
 Provides-Extra: dev
 Requires-Dist: black; extra == 'dev'
@@ -29,6 +30,8 @@ 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 🎨

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.2.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-eidos/__init__.py,sha256=wPMqILVs6Iof510BteshYDZgsW-08w_RfenImYKlPlM,40
-eidos/styles.py,sha256=QupOwC0VuSZ6zdNJiNFT_PqTnvbJvaNplKO5M5xzMVI,2380
-eidos/tags.py,sha256=9jX9u8QLHjv48vRB7yorR3dV25UEt3AjgUlYPJDcxPM,3975
-eidos/utils.py,sha256=dncLrIjn78x6HW-lX1feG76jtAilfLaxsRmJ8ewCCCs,1922
-eidos/components/headers.py,sha256=qE5xa2Yt545FGlBAITPjPAU5CQkz0cnYq7biYcb6mB0,939
-eidos/css/styles.css,sha256=4VWOWe436DQRXBN4b6g6tsIRqXsYJrwuoKNnsrQQv_M,7643
-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
-eidosui-0.2.0.dist-info/METADATA,sha256=ME2HeKBZS9nenM2SpdQ5FBYbA51rlU0CnO3UvoDy44g,4609
-eidosui-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-eidosui-0.2.0.dist-info/licenses/LICENSE,sha256=evjPJs6lg9eka9CYtC6ErQrZ71IovVbdvZqqz3ax8E8,1064
-eidosui-0.2.0.dist-info/RECORD,,