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

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/styles.py

@@ -0,0 +1,80 @@
+"""CSS class constants for EidosUI components.
+
+This module provides Python constants for CSS classes that exist in styles.css.
+Only includes classes that are actually defined in the CSS file.
+"""
+
+from typing import Final
+
+class Theme:
+    """Theme-related CSS classes from styles.css."""
+    body: Final[str] = "eidos-body"
+
+class Buttons:
+    """Button-related CSS classes from styles.css."""
+    
+    # Base button class (required for all buttons)
+    base: Final[str] = "eidos-btn"
+    
+    # Button variants
+    primary: Final[str] = "eidos-btn-primary"
+    secondary: Final[str] = "eidos-btn-secondary"
+    ghost: Final[str] = "eidos-btn-ghost"
+    outline: Final[str] = "eidos-btn-outline"
+    success: Final[str] = "eidos-btn-success"
+    error: Final[str] = "eidos-btn-error"
+    cta: Final[str] = "eidos-btn-cta"
+
+class Typography:
+    """Typography-related CSS classes from styles.css."""
+
+    h1: Final[str] = "eidos-h1"
+    h2: Final[str] = "eidos-h2"
+    h3: Final[str] = "eidos-h3"
+    h4: Final[str] = "eidos-h4"
+    h5: Final[str] = "eidos-h5"
+    h6: Final[str] = "eidos-h6"
+
+class Semantic:
+    """Semantic HTML element CSS classes from styles.css."""
+    
+    # Text formatting
+    strong: Final[str] = "eidos-strong"
+    i: Final[str] = "eidos-i"
+    small: Final[str] = "eidos-small"
+    del_: Final[str] = "eidos-del"  # del is reserved keyword
+    abbr: Final[str] = "eidos-abbr"
+    var: Final[str] = "eidos-var"
+    mark: Final[str] = "eidos-mark"
+    time: Final[str] = "eidos-time"
+    
+    # Code elements
+    code: Final[str] = "eidos-code"
+    pre: Final[str] = "eidos-pre"
+    kbd: Final[str] = "eidos-kbd"
+    samp: Final[str] = "eidos-samp"
+    
+    # Structural elements
+    blockquote: Final[str] = "eidos-blockquote"
+    cite: Final[str] = "eidos-cite"
+    address: Final[str] = "eidos-address"
+    hr: Final[str] = "eidos-hr"
+    
+    # Interactive elements
+    details: Final[str] = "eidos-details"
+    summary: Final[str] = "eidos-summary"
+    details_content: Final[str] = "eidos-details-content"
+    
+    # Definition list
+    dl: Final[str] = "eidos-dl"
+    dt: Final[str] = "eidos-dt"
+    dd: Final[str] = "eidos-dd"
+    
+    # Figure
+    figure: Final[str] = "eidos-figure"
+    figcaption: Final[str] = "eidos-figcaption"
+
+# Create singleton instance for easy access
+buttons = Buttons()
+typography = Typography()
+semantic = Semantic()

eidos/tags.py

@@ -0,0 +1,99 @@
+from typing import Optional, Literal, Any, Union
+import air
+from . import styles
+from .utils import stringify
+
+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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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(class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Hr(class_=stringify(styles.semantic.hr, class_), **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: 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: 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: 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: 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: 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: Any, class_: Optional[Union[str, list[str]]] = None, **kwargs: Any) -> air.Tag:
+    return air.Figcaption(*content, class_=stringify(styles.semantic.figcaption, class_), **kwargs)