dars-framework 1.2.3__py3-none-any.whl

dars/core/component.py

@@ -0,0 +1,284 @@
+from typing import Dict, Any, List, Optional, Callable, Union, Type
+from abc import ABC, abstractmethod
+from dars.core.events import EventTypes
+
+class ComponentQuery:
+    def __init__(self, components: List['Component']):
+        self.components = components
+
+    def find(self, 
+             id: Optional[str] = None,
+             class_name: Optional[str] = None,
+             type: Optional[Union[Type['Component'], str]] = None,
+             predicate: Optional[Callable[['Component'], bool]] = None) -> 'ComponentQuery':
+        
+        """Searches for components within the currently selected components."""  
+        results: List['Component'] = []
+        
+        def match_component(comp: Component) -> bool:
+            if id is not None and comp.id != id:
+                return False
+            if class_name is not None and comp.class_name != class_name:
+                return False
+            if type is not None:
+                if isinstance(type, str):
+                    if comp.__class__.__name__ != type:
+                        return False
+                elif not isinstance(comp, type):
+                    return False
+            if predicate is not None and not predicate(comp):
+                return False
+            return True
+        
+        # Buscar en los hijos de todos los componentes actuales
+        for component in self.components:
+            for child in component.children:
+                if match_component(child):
+                    results.append(child)
+                # Buscar recursivamente en los hijos del hijo
+                for descendant in ComponentQuery([child]).find().get():
+                    if match_component(descendant):
+                        results.append(descendant)
+        
+        return ComponentQuery(results)
+
+    def attr(self, **attrs) -> 'ComponentQuery':
+        """Modifies the attributes of all found components."""  
+        for component in self.components:
+            for key, value in attrs.items():
+                # Manejo especial para atributos comunes
+                if key == 'style':
+                    component.style.update(value)
+                    continue
+                elif key == 'class_name':
+                    component.class_name = value
+                    continue
+                elif key == 'events':
+                    component.events.update(value)
+                    continue
+                
+                # Intenta establecer el atributo directamente si existe
+                if hasattr(component, key):
+                    setattr(component, key, value)
+                # Si no existe como atributo directo, guárdalo en props
+                else:
+                    component.props[key] = value
+        return self
+
+    def get(self) -> List['Component']:
+        """Returns the list of found components."""  
+        return self.components
+
+    def first(self) -> Optional['Component']:
+        """Returns the first found component, or None if there is none."""  
+        return self.components[0] if self.components else None
+
+class Component(ABC):
+    def __init__(self, **props):
+        self.props = props
+        self.children: List[Component] = []
+        self.parent: Optional[Component] = None
+        self.id: Optional[str] = props.get('id')
+        self.class_name: str = props.get("class_name", self.__class__.__name__)
+        self.style: Dict[str, Any] = props.get('style', {})
+        self.events: Dict[str, Callable] = {}
+        # Stable identity hint for children reconciliation in VDOM (optional)
+        self.key: Optional[str] = props.get('key')
+
+        # Generic on_* props -> register as events on any component
+        if props:
+            on_map = {
+                'on_click': EventTypes.CLICK,
+                'on_double_click': EventTypes.DOUBLE_CLICK,
+                'on_mouse_down': EventTypes.MOUSE_DOWN,
+                'on_mouse_up': EventTypes.MOUSE_UP,
+                'on_mouse_enter': EventTypes.MOUSE_ENTER,
+                'on_mouse_leave': EventTypes.MOUSE_LEAVE,
+                'on_mouse_move': EventTypes.MOUSE_MOVE,
+                'on_key_down': EventTypes.KEY_DOWN,
+                'on_key_up': EventTypes.KEY_UP,
+                'on_key_press': EventTypes.KEY_PRESS,
+                'on_change': EventTypes.CHANGE,
+                'on_input': EventTypes.INPUT,
+                'on_submit': EventTypes.SUBMIT,
+                'on_focus': EventTypes.FOCUS,
+                'on_blur': EventTypes.BLUR,
+                'on_load': EventTypes.LOAD,
+                'on_error': EventTypes.ERROR,
+                'on_resize': EventTypes.RESIZE,
+            }
+            for k, v in list(props.items()):
+                if k in on_map and v is not None:
+                    handler = v
+                    # Normalize handler to Script-like if possible
+                    try:
+                        from dars.scripts.script import Script
+                        if not isinstance(handler, Script):
+                            if callable(handler):
+                                from dars.scripts.dscript import dScript
+                                handler = dScript(handler.__code__)
+                    except Exception:
+                        # Best-effort: keep as-is (string or callable)
+                        pass
+                    self.set_event(on_map[k], handler)
+        
+    def add_child(self, child: 'Component'):
+        if isinstance(child, type) and issubclass(child, Component):
+            raise TypeError(f"The class {child.__name__} was passed instead of an instance. You should use {child.__name__}(...).")
+        child.parent = self
+        self.children.append(child)
+        
+    def set_event(self, event_name: str, handler: Callable):
+        self.events[event_name] = handler
+        
+    def find(self, 
+             id: Optional[str] = None,
+             class_name: Optional[str] = None,
+             type: Optional[Union[Type['Component'], str]] = None,
+             predicate: Optional[Callable[['Component'], bool]] = None) -> ComponentQuery:
+        """Searches for components that match the specified criteria.
+
+            Args:
+                id: Search by component ID
+                class_name: Search by CSS class name
+                type: Search by component type (class or class name)
+                predicate: Custom filter function that takes a component and returns bool
+
+            Returns:
+                ComponentQuery that allows chaining operations and modifying attributes
+        """
+
+        results: List[Component] = []
+        
+        def match_component(comp: Component) -> bool:
+            if id is not None and comp.id != id:
+                return False
+            if class_name is not None and comp.class_name != class_name:
+                return False
+            if type is not None:
+                if isinstance(type, str):
+                    if comp.__class__.__name__ != type:
+                        return False
+                elif not isinstance(comp, type):
+                    return False
+            if predicate is not None and not predicate(comp):
+                return False
+            return True
+        
+        def search_recursive(component: Component):
+            if match_component(component):
+                results.append(component)
+            for child in component.children:
+                search_recursive(child)
+        
+        search_recursive(self)
+        return ComponentQuery(results)
+
+    def attr(self, **attrs) -> Union['Component', dict]:
+        """If kwargs are provided, sets attributes on the component (chained setter).  
+           If no kwargs are provided, returns a dict with all editable component attributes (getter).  
+           Example:
+                c.attr(id='new', style={'color': 'red'})
+                c.attr()['id']  # getter
+        """
+
+        if attrs:
+            if 'defer' in attrs:
+                try:
+                    d = attrs.pop('defer')
+                    if d:
+                        return DeferredAttr(self, attrs)
+                except Exception:
+                    pass
+            for key, value in attrs.items():
+                if key == 'style':
+                    self.style.update(value)
+                    continue
+                elif key == 'class_name':
+                    self.class_name = value
+                    continue
+                elif key == 'events':
+                    self.events.update(value)
+                    continue
+                # Allow setting on_* event properties via attr()
+                if key.startswith('on_') and value is not None:
+                    try:
+                        event_name = {
+                            'on_click': EventTypes.CLICK,
+                            'on_double_click': EventTypes.DOUBLE_CLICK,
+                            'on_mouse_down': EventTypes.MOUSE_DOWN,
+                            'on_mouse_up': EventTypes.MOUSE_UP,
+                            'on_mouse_enter': EventTypes.MOUSE_ENTER,
+                            'on_mouse_leave': EventTypes.MOUSE_LEAVE,
+                            'on_mouse_move': EventTypes.MOUSE_MOVE,
+                            'on_key_down': EventTypes.KEY_DOWN,
+                            'on_key_up': EventTypes.KEY_UP,
+                            'on_key_press': EventTypes.KEY_PRESS,
+                            'on_change': EventTypes.CHANGE,
+                            'on_input': EventTypes.INPUT,
+                            'on_submit': EventTypes.SUBMIT,
+                            'on_focus': EventTypes.FOCUS,
+                            'on_blur': EventTypes.BLUR,
+                            'on_load': EventTypes.LOAD,
+                            'on_error': EventTypes.ERROR,
+                            'on_resize': EventTypes.RESIZE,
+                        }.get(key)
+                        if event_name:
+                            handler = value
+                            from dars.scripts.script import Script
+                            if not isinstance(handler, Script):
+                                if callable(handler):
+                                    from dars.scripts.dscript import dScript
+                                    handler = dScript(handler.__code__)
+                            self.set_event(event_name, handler)
+                            continue
+                    except Exception:
+                        # If any error, fall back to setting as a prop
+                        pass
+                if hasattr(self, key):
+                    setattr(self, key, value)
+                else:
+                    self.props[key] = value
+            return self
+        # Getter: devolver todos los atributos editables
+        d = dict(self.props)
+        d['id'] = self.id
+        d['class_name'] = self.class_name
+        d['style'] = self.style
+        d['events'] = self.events
+        return d
+
+    def mod(self, **attrs):
+        return DeferredAttr(self, attrs)
+
+
+class DeferredAttr:
+    def __init__(self, component: 'Component', attrs: Dict[str, Any]):
+        self.component = component
+        self.attrs = attrs or {}
+
+    def clone_with(self) -> 'Component':
+        try:
+            import copy
+            clone = copy.copy(self.component)
+        except Exception:
+            clone = self.component
+        try:
+            if hasattr(clone, 'attr') and callable(getattr(clone, 'attr')):
+                clone.attr(**self.attrs)
+        except Exception:
+            pass
+        return clone
+
+    def render_children(self, exporter: 'Exporter') -> str:
+        """Render all children of the component using the exporter."""
+        children_html = ""
+        for child in self.children:
+            children_html += exporter.render_component(child)
+        return children_html
+    
+    @abstractmethod
+    def render(self, exporter: 'Exporter') -> str:
+        pass
+
+

dars/core/events.py

@@ -0,0 +1,102 @@
+from typing import Callable, Dict, Any, Optional
+from abc import ABC, abstractmethod
+
+class EventHandler:
+    """Event handler for components"""
+    
+    def __init__(self, handler: Callable, event_type: str):
+        self.handler = handler
+        self.event_type = event_type
+        self.id = f"event_{id(self)}"
+    
+    def __call__(self, *args, **kwargs):
+        return self.handler(*args, **kwargs)
+
+class EventManager:
+    """Event manager for the application"""
+    
+    def __init__(self):
+        self.handlers: Dict[str, EventHandler] = {}
+        self.component_events: Dict[str, Dict[str, EventHandler]] = {}
+    
+    def register_event(self, component_id: str, event_type: str, handler: Callable) -> str:
+        """Registers an event for a component"""
+        event_handler = EventHandler(handler, event_type)
+        
+        if component_id not in self.component_events:
+            self.component_events[component_id] = {}
+        
+        self.component_events[component_id][event_type] = event_handler
+        self.handlers[event_handler.id] = event_handler
+        
+        return event_handler.id
+    
+    def get_event_handler(self, handler_id: str) -> Optional[EventHandler]:
+        """Gets all events of a component by ID"""
+
+        return self.handlers.get(handler_id)
+    
+    def get_component_events(self, component_id: str) -> Dict[str, EventHandler]:
+        """Gets all events of a component"""
+        return self.component_events.get(component_id, {})
+    
+    def remove_event(self, component_id: str, event_type: str):
+        """Removes an event from a component"""
+        if component_id in self.component_events:
+            if event_type in self.component_events[component_id]:
+                handler = self.component_events[component_id][event_type]
+                del self.handlers[handler.id]
+                del self.component_events[component_id][event_type]
+
+class EventEmitter(ABC):
+    """Base class for components that can emit events"""
+    
+    def __init__(self):
+        self.event_manager = EventManager()
+    
+    def on(self, event_type: str, handler: Callable) -> str:
+        """Registers an event handler"""
+        component_id = getattr(self, 'id', str(id(self)))
+        return self.event_manager.register_event(component_id, event_type, handler)
+    
+    def off(self, event_type: str):
+        """Removes an event handler"""
+        component_id = getattr(self, 'id', str(id(self)))
+        self.event_manager.remove_event(component_id, event_type)
+    
+    @abstractmethod
+    def emit(self, event_type: str, *args, **kwargs):
+        """Emits an event"""
+        pass
+
+# Tipos de eventos estándar
+class EventTypes:
+    # Eventos de mouse
+    CLICK = "click"
+    DOUBLE_CLICK = "dblclick"
+    MOUSE_DOWN = "mousedown"
+    MOUSE_UP = "mouseup"
+    MOUSE_ENTER = "mouseenter"
+    MOUSE_LEAVE = "mouseleave"
+    MOUSE_MOVE = "mousemove"
+    
+    # Eventos de teclado
+    KEY_DOWN = "keydown"
+    KEY_UP = "keyup"
+    KEY_PRESS = "keypress"
+    
+    # Eventos de formulario
+    CHANGE = "change"
+    INPUT = "input"
+    SUBMIT = "submit"
+    FOCUS = "focus"
+    BLUR = "blur"
+    
+    # Eventos de carga
+    LOAD = "load"
+    ERROR = "error"
+    RESIZE = "resize"
+    
+    # Eventos personalizados
+    CUSTOM = "custom"
+

dars/core/js_bridge.py

@@ -0,0 +1,99 @@
+import os
+import subprocess
+import tempfile
+from typing import List, Optional, Tuple
+
+
+def _run(cmd: List[str], cwd: Optional[str] = None, live: bool = False) -> Tuple[int, str, str]:
+    try:
+        if live:
+            p = subprocess.run(cmd, cwd=cwd)
+            return (p.returncode or 0, "", "")
+        p = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True)
+        return p.returncode, (p.stdout or ""), (p.stderr or "")
+    except Exception as e:
+        return 1, "", str(e)
+
+
+def which(name: str) -> Optional[str]:
+    cmd = ["where", name] if os.name == 'nt' else ["which", name]
+    code, out, _ = _run(cmd)
+    if code == 0 and out:
+        return out.strip().splitlines()[0]
+    return None
+
+
+def has_node() -> bool:
+    return which("node") is not None
+
+
+def has_bun() -> bool:
+    return which("bun") is not None
+
+
+def bun_add(packages: List[str], dev: bool = True, cwd: Optional[str] = None) -> bool:
+    if not has_bun():
+        return False
+    args = ["bun", "add"]
+    if dev:
+        args.append("-d")
+    args.extend(packages)
+    code, _, _ = _run(args, cwd=cwd, live=True)
+    return code == 0
+
+
+def node_run(code: str) -> Tuple[int, str, str]:
+    if not has_node():
+        return 1, "", "node not found"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mjs", mode="w", encoding="utf-8") as tf:
+        tf.write(code)
+        temp = tf.name
+    try:
+        return _run(["node", temp])
+    finally:
+        try:
+            os.remove(temp)
+        except Exception:
+            pass
+
+
+def esbuild_available() -> bool:
+    # Prefer bun esbuild
+    if has_bun():
+        # bun x esbuild --version
+        code, out, _ = _run(["bun", "x", "esbuild", "--version"])
+        if code == 0:
+            return True
+    # Node npx fallback
+    if has_node():
+        code, out, _ = _run(["npx", "--yes", "esbuild", "--version"])  # --yes to avoid prompt
+        if code == 0:
+            return True
+    return False
+
+
+def ensure_esbuild(cwd: Optional[str] = None) -> bool:
+    if esbuild_available():
+        return True
+    # Try to add via bun (dev dep)
+    if has_bun():
+        ok = bun_add(["esbuild"], dev=True, cwd=cwd)
+        return ok and esbuild_available()
+    return False
+
+
+def esbuild_minify_js(src_path: str, out_path: Optional[str] = None) -> bool:
+    if not esbuild_available() and not ensure_esbuild(os.path.dirname(src_path)):
+        return False
+    out = out_path or src_path
+    if has_bun():
+        code, _, _ = _run(["bun", "x", "esbuild", src_path, "--minify", "--legal-comments=none", "--platform=browser", "--format=esm", f"--outfile={out}"])
+        return code == 0
+    # Node fallback via npx
+    code, _, _ = _run(["npx", "--yes", "esbuild", src_path, "--minify", "--legal-comments=none", "--platform=browser", "--format=esm", f"--outfile={out}"])
+    return code == 0
+
+
+def esbuild_minify_css(src_path: str, out_path: Optional[str] = None) -> bool:
+    # esbuild can minify CSS if input is CSS
+    return esbuild_minify_js(src_path, out_path)

dars/core/properties.py

@@ -0,0 +1,127 @@
+from typing import Union, Optional, Dict, Any, Callable
+from dataclasses import dataclass
+
+@dataclass
+class StyleProps:
+    """Style properties for UI components"""
+    # Dimensiones
+    width: Optional[Union[str, int]] = None
+    height: Optional[Union[str, int]] = None
+    min_width: Optional[Union[str, int]] = None
+    min_height: Optional[Union[str, int]] = None
+    max_width: Optional[Union[str, int]] = None
+    max_height: Optional[Union[str, int]] = None
+    
+    # Espaciado
+    margin: Optional[Union[str, int]] = None
+    margin_top: Optional[Union[str, int]] = None
+    margin_right: Optional[Union[str, int]] = None
+    margin_bottom: Optional[Union[str, int]] = None
+    margin_left: Optional[Union[str, int]] = None
+    padding: Optional[Union[str, int]] = None
+    padding_top: Optional[Union[str, int]] = None
+    padding_right: Optional[Union[str, int]] = None
+    padding_bottom: Optional[Union[str, int]] = None
+    padding_left: Optional[Union[str, int]] = None
+    
+    # Colores
+    background_color: Optional[str] = None
+    color: Optional[str] = None
+    border_color: Optional[str] = None
+    
+    # Tipografía
+    font_size: Optional[Union[str, int]] = None
+    font_family: Optional[str] = None
+    font_weight: Optional[Union[str, int]] = None
+    font_style: Optional[str] = None
+    text_align: Optional[str] = None
+    text_decoration: Optional[str] = None
+    line_height: Optional[Union[str, int]] = None
+    
+    # Bordes
+    border: Optional[str] = None
+    border_width: Optional[Union[str, int]] = None
+    border_style: Optional[str] = None
+    border_radius: Optional[Union[str, int]] = None
+    
+    # Layout
+    display: Optional[str] = None
+    position: Optional[str] = None
+    top: Optional[Union[str, int]] = None
+    right: Optional[Union[str, int]] = None
+    bottom: Optional[Union[str, int]] = None
+    left: Optional[Union[str, int]] = None
+    z_index: Optional[int] = None
+    
+    # Flexbox
+    flex_direction: Optional[str] = None
+    flex_wrap: Optional[str] = None
+    justify_content: Optional[str] = None
+    align_items: Optional[str] = None
+    align_content: Optional[str] = None
+    flex: Optional[Union[str, int]] = None
+    flex_grow: Optional[int] = None
+    flex_shrink: Optional[int] = None
+    flex_basis: Optional[Union[str, int]] = None
+    
+    # Grid
+    grid_template_columns: Optional[str] = None
+    grid_template_rows: Optional[str] = None
+    grid_gap: Optional[Union[str, int]] = None
+    grid_column: Optional[str] = None
+    grid_row: Optional[str] = None
+    
+    # Efectos
+    opacity: Optional[float] = None
+    box_shadow: Optional[str] = None
+    transform: Optional[str] = None
+    transition: Optional[str] = None
+    
+    # Overflow
+    overflow: Optional[str] = None
+    overflow_x: Optional[str] = None
+    overflow_y: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convierte las propiedades a un diccionario, excluyendo valores None"""
+        result = {}
+        for key, value in self.__dict__.items():
+            if value is not None:
+                # Convertir snake_case a kebab-case para CSS
+                css_key = key.replace('_', '-')
+                result[css_key] = value
+        return result
+
+@dataclass
+class EventProps:
+    """Properties of events for UI components"""
+    on_click: Optional[Callable] = None
+    on_double_click: Optional[Callable] = None
+    on_mouse_enter: Optional[Callable] = None
+    on_mouse_leave: Optional[Callable] = None
+    on_mouse_down: Optional[Callable] = None
+    on_mouse_up: Optional[Callable] = None
+    on_key_down: Optional[Callable] = None
+    on_key_up: Optional[Callable] = None
+    on_focus: Optional[Callable] = None
+    on_blur: Optional[Callable] = None
+    on_change: Optional[Callable] = None
+    on_input: Optional[Callable] = None
+    on_submit: Optional[Callable] = None
+    on_load: Optional[Callable] = None
+    on_error: Optional[Callable] = None
+
+def normalize_style_value(value: Union[str, int]) -> str:
+    """Normalizes a style value to a CSS string"""
+    if isinstance(value, int):
+        return f"{value}px"
+    return str(value)
+
+def merge_styles(*styles: Dict[str, Any]) -> Dict[str, Any]:
+    """Combines multiple style dictionaries"""
+    result = {}
+    for style in styles:
+        if style:
+            result.update(style)
+    return result
+