violit 0.0.1__py3-none-any.whl

violit/broadcast_primitives.py

@@ -0,0 +1,197 @@
+"""UI primitives for broadcast system"""
+
+# UI Primitives Definition
+
+UI_PRIMITIVES = {
+    # List Operations
+    'list.append': {
+        'description': 'Append item to list (supports custom HTML)',
+        'params': ['list_key', 'item_data', 'position'],
+        'defaults': {'position': 'prepend'},
+        'notes': 'Uses item_data.html if available, otherwise creates default card',
+        'example': {
+            'type': 'list.append',
+            'params': {
+                'list_key': 'posts',
+                'item_data': 'e.detail',  # Use custom HTML if e.detail.html exists
+                'position': 'prepend'
+            }
+        }
+    },
+    'list.remove': {
+        'description': 'Remove item from list',
+        'params': ['list_key', 'item_id'],
+        'defaults': {},
+        'example': {
+            'type': 'list.remove',
+            'params': {
+                'list_key': 'posts',
+                'item_id': 'e.detail.post_id'
+            }
+        }
+    },
+    'list.update': {
+        'description': 'Update specific item in list',
+        'params': ['list_key', 'item_id', 'item_data'],
+        'defaults': {},
+        'example': {
+            'type': 'list.update',
+            'params': {
+                'list_key': 'posts',
+                'item_id': 'e.detail.id',
+                'item_data': 'e.detail'
+            }
+        }
+    },
+    'list.replace_all': {
+        'description': 'Replace entire list (snapshot sync)',
+        'params': ['list_key', 'items'],
+        'defaults': {},
+        'example': {
+            'type': 'list.replace_all',
+            'params': {
+                'list_key': 'posts',
+                'items': 'e.detail.posts'
+            }
+        }
+    },
+    
+    # State Operations
+    'state.set': {
+        'description': 'Set state value',
+        'params': ['state_key', 'value'],
+        'defaults': {},
+        'example': {
+            'type': 'state.set',
+            'params': {
+                'state_key': 'user_count',
+                'value': 'e.detail.count'
+            }
+        }
+    },
+    'state.increment': {
+        'description': 'Increment state value (numeric only)',
+        'params': ['state_key', 'amount'],
+        'defaults': {'amount': 1},
+        'example': {
+            'type': 'state.increment',
+            'params': {
+                'state_key': 'post_count',
+                'amount': 1
+            }
+        }
+    },
+    'state.decrement': {
+        'description': 'Decrement state value (numeric only)',
+        'params': ['state_key', 'amount'],
+        'defaults': {'amount': 1},
+        'example': {
+            'type': 'state.decrement',
+            'params': {
+                'state_key': 'post_count',
+                'amount': 1
+            }
+        }
+    },
+    
+    # DOM Operations
+    'dom.insert': {
+        'description': 'Insert HTML element',
+        'params': ['container_id', 'html', 'position'],
+        'defaults': {'position': 'prepend'},
+        'example': {
+            'type': 'dom.insert',
+            'params': {
+                'container_id': 'notifications',
+                'html': 'e.detail.html',
+                'position': 'prepend'
+            }
+        }
+    },
+    'dom.remove': {
+        'description': 'Remove DOM element',
+        'params': ['selector', 'animate'],
+        'defaults': {'animate': True},
+        'example': {
+            'type': 'dom.remove',
+            'params': {
+                'selector': '[data-item-id="123"]',
+                'animate': True
+            }
+        }
+    },
+    'dom.update': {
+        'description': 'Update DOM element content',
+        'params': ['selector', 'html'],
+        'defaults': {},
+        'example': {
+            'type': 'dom.update',
+            'params': {
+                'selector': '#status',
+                'html': 'e.detail.status'
+            }
+        }
+    },
+    
+    # Feedback Operations
+    'feedback.toast': {
+        'description': 'Display toast notification',
+        'params': ['message', 'variant', 'duration'],
+        'defaults': {'variant': 'neutral', 'duration': 3000},
+        'example': {
+            'type': 'feedback.toast',
+            'params': {
+                'message': "'Task completed!'",
+                'variant': 'success',
+                'duration': 3000
+            }
+        }
+    },
+    'feedback.badge': {
+        'description': 'Update badge value',
+        'params': ['badge_id', 'value'],
+        'defaults': {},
+        'example': {
+            'type': 'feedback.badge',
+            'params': {
+                'badge_id': 'notification-badge',
+                'value': 'e.detail.count'
+            }
+        }
+    },
+}
+
+
+def get_primitive_names():
+    """Return list of available primitive names"""
+    return list(UI_PRIMITIVES.keys())
+
+
+def get_primitive_info(primitive_name):
+    """Return info for a specific primitive"""
+    return UI_PRIMITIVES.get(primitive_name)
+
+
+def validate_primitive(primitive_dict):
+    """Validate primitive dictionary structure"""
+    if 'type' not in primitive_dict:
+        return False, "Missing 'type' field"
+    
+    prim_type = primitive_dict['type']
+    if prim_type not in UI_PRIMITIVES:
+        return False, f"Unknown primitive: {prim_type}"
+    
+    if 'params' not in primitive_dict:
+        return False, "Missing 'params' field"
+    
+    prim_info = UI_PRIMITIVES[prim_type]
+    required_params = prim_info['params']
+    provided_params = primitive_dict['params'].keys()
+    defaults = prim_info.get('defaults', {})
+    missing_params = [p for p in required_params if p not in provided_params and p not in defaults]
+    
+    if missing_params:
+        return False, f"Missing required params: {missing_params}"
+    
+    return True, "OK"
+

violit/component.py

@@ -0,0 +1,38 @@
+from typing import Any, Optional
+import html
+
+class Component:
+    def __init__(self, tag: Optional[str], id: str, escape_content: bool = False, **props):
+        self.tag = tag
+        self.id = id
+        self.escape_content = escape_content  # XSS protection
+        self.props = props
+
+    def render(self) -> str:
+        if self.tag is None:
+            content = str(self.props.get('content', ''))
+            # Escape content if enabled
+            return html.escape(content) if self.escape_content else content
+            
+        attrs = []
+        for k, v in self.props.items():
+            if k == 'content': continue
+            clean_k = k.replace('_', '-') if not k.startswith('on') else k
+            if clean_k.startswith('on'):
+                attrs.append(f'{clean_k}="{v}"')
+            else:
+                if v is True: attrs.append(clean_k)
+                elif v is False or v is None: continue
+                else: 
+                    # Escape attribute values for XSS protection
+                    escaped_v = html.escape(str(v), quote=True)
+                    attrs.append(f'{clean_k}="{escaped_v}"')
+        
+        props_str = " ".join(attrs)
+        content = self.props.get('content', '')
+        
+        # Escape content if enabled
+        if self.escape_content:
+            content = html.escape(str(content))
+        
+        return f"<{self.tag} id=\"{self.id}\" {props_str}>{content}</{self.tag}>"

violit/context.py

@@ -0,0 +1,10 @@
+import contextvars
+
+# Global Contexts
+session_ctx = contextvars.ContextVar("session_id", default=None)
+rendering_ctx = contextvars.ContextVar("rendering_component", default=None)
+fragment_ctx = contextvars.ContextVar("current_fragment", default=None)
+layout_ctx = contextvars.ContextVar("layout_ctx", default="main")  # "main" or "sidebar"
+
+# Global Reference for App Instance (used for initial theme sync)
+app_instance_ref = [None]

violit/engine.py

@@ -0,0 +1,33 @@
+from typing import List, Dict, Callable
+from starlette.websockets import WebSocket
+from .component import Component
+
+class LiteEngine:
+    def click_attrs(self, cid: str):
+        return {"hx-post": f"/action/{cid}", "hx-swap": "none"}
+
+    def wrap_oob(self, components: List[Component]):
+        html = ""
+        for comp in components:
+            rendered = comp.render().strip()
+            # Inject hx-swap-oob="true" into the root tag of the component
+            tag_end = rendered.find(' ')
+            if tag_end == -1: tag_end = rendered.find('>')
+            html += rendered[:tag_end] + ' hx-swap-oob="true"' + rendered[tag_end:]
+        return html
+
+class WsEngine:
+    def __init__(self):
+        self.sockets: Dict[str, WebSocket] = {}
+        
+    def click_attrs(self, cid: str):
+        return {"onclick": f"window.sendAction('{cid}')"}
+        
+    async def push_updates(self, sid: str, components: List[Component]):
+        if sid in self.sockets:
+            payload = [{"id": c.id, "html": c.render()} for c in components]
+            await self.sockets[sid].send_json({"type": "update", "payload": payload})
+
+    async def push_eval(self, sid: str, code: str):
+        if sid in self.sockets:
+            await self.sockets[sid].send_json({"type": "eval", "code": code})

violit/state.py

@@ -0,0 +1,76 @@
+from typing import Any, Dict, Set
+from cachetools import TTLCache
+from .context import session_ctx, rendering_ctx, app_instance_ref
+from .theme import Theme
+
+class DependencyTracker:
+    def __init__(self):
+        self.subscribers: Dict[str, Set[str]] = {}
+    
+    def register_dependency(self, state_name: str, component_id: str):
+        if state_name not in self.subscribers:
+            self.subscribers[state_name] = set()
+        self.subscribers[state_name].add(component_id)
+
+    def get_dirty_components(self, state_name: str) -> Set[str]:
+        return self.subscribers.get(state_name, set())
+
+GLOBAL_STORE = TTLCache(maxsize=1000, ttl=1800)
+
+def get_session_store():
+    sid = session_ctx.get()
+    if sid not in GLOBAL_STORE:
+        initial_theme = 'light'
+        if app_instance_ref[0]:
+            initial_theme = app_instance_ref[0].theme_manager.preset_name
+            
+        GLOBAL_STORE[sid] = {
+            'states': {}, 
+            'tracker': DependencyTracker(),
+            'builders': {},
+            'actions': {},
+            'component_count': 0,
+            'fragment_components': {},
+            'order': [],
+            'sidebar_order': [],
+            'theme': Theme(initial_theme)
+        }
+    return GLOBAL_STORE[sid]
+
+class State:
+    def __init__(self, name: str, default_value: Any):
+        object.__setattr__(self, 'name', name)
+        object.__setattr__(self, 'default_value', default_value)
+
+    @property
+    def value(self):
+        store = get_session_store()
+        current_comp_id = rendering_ctx.get()
+        if current_comp_id:
+            store['tracker'].register_dependency(self.name, current_comp_id)
+        return store['states'].get(self.name, self.default_value)
+    
+    @value.setter
+    def value(self, new_value: Any):
+        self.set(new_value)
+
+    def set(self, new_value: Any):
+        store = get_session_store()
+        store['states'][self.name] = new_value
+        if 'dirty_states' not in store: store['dirty_states'] = set()
+        store['dirty_states'].add(self.name)
+    
+    def __setattr__(self, attr: str, val: Any):
+        if attr == 'value':
+            self.set(val)
+        else:
+            object.__setattr__(self, attr, val)
+
+    def __str__(self):
+        return str(self.value)
+    
+    def __call__(self):
+        return self.value
+    
+    def __repr__(self):
+        return f"State({self.name}, {self.value})"