dars-framework 1.0.0__py3-none-any.whl

dars/core/events.py

@@ -0,0 +1,101 @@
+from typing import Callable, Dict, Any, Optional
+from abc import ABC, abstractmethod
+
+class EventHandler:
+    """Manejador de eventos para componentes"""
+    
+    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:
+    """Gestor de eventos para la aplicación"""
+    
+    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:
+        """Registra un evento para un componente"""
+        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]:
+        """Obtiene un manejador de eventos por su ID"""
+        return self.handlers.get(handler_id)
+    
+    def get_component_events(self, component_id: str) -> Dict[str, EventHandler]:
+        """Obtiene todos los eventos de un componente"""
+        return self.component_events.get(component_id, {})
+    
+    def remove_event(self, component_id: str, event_type: str):
+        """Elimina un evento de un componente"""
+        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):
+    """Clase base para componentes que pueden emitir eventos"""
+    
+    def __init__(self):
+        self.event_manager = EventManager()
+    
+    def on(self, event_type: str, handler: Callable) -> str:
+        """Registra un manejador de eventos"""
+        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):
+        """Elimina un manejador de eventos"""
+        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):
+        """Emite un evento"""
+        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/properties.py

@@ -0,0 +1,127 @@
+from typing import Union, Optional, Dict, Any, Callable
+from dataclasses import dataclass
+
+@dataclass
+class StyleProps:
+    """Propiedades de estilo para componentes UI"""
+    # 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:
+    """Propiedades de eventos para componentes UI"""
+    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:
+    """Normaliza un valor de estilo a string CSS"""
+    if isinstance(value, int):
+        return f"{value}px"
+    return str(value)
+
+def merge_styles(*styles: Dict[str, Any]) -> Dict[str, Any]:
+    """Combina múltiples diccionarios de estilos"""
+    result = {}
+    for style in styles:
+        if style:
+            result.update(style)
+    return result
+

dars/exporters/base.py

@@ -0,0 +1,69 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+import os
+
+class Exporter(ABC):
+    """Clase base para todos los exportadores"""
+    
+    def __init__(self):
+        self.templates_path = os.path.join(os.path.dirname(__file__), "..", "templates")
+        
+    @abstractmethod
+    def export(self, app: 'App', output_path: str) -> bool:
+        """Exporta la aplicación al formato específico"""
+        pass
+        
+    @abstractmethod
+    def render_component(self, component: 'Component') -> str:
+        """Renderiza un componente individual"""
+        pass
+        
+    def load_template(self, template_name: str) -> str:
+        """Carga una plantilla desde el directorio de templates"""
+        template_path = os.path.join(self.templates_path, self.get_platform(), template_name)
+        try:
+            with open(template_path, 'r', encoding='utf-8') as f:
+                return f.read()
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Plantilla no encontrada: {template_path}")
+            
+    @abstractmethod
+    def get_platform(self) -> str:
+        """Retorna el nombre de la plataforma (html, react, etc.)"""
+        pass
+        
+    def create_output_directory(self, output_path: str):
+        """Crea el directorio de salida si no existe"""
+        os.makedirs(output_path, exist_ok=True)
+        
+    def write_file(self, file_path: str, content: str):
+        """Escribe contenido a un archivo"""
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+            
+    def copy_file(self, source_path: str, dest_path: str):
+        """Copia un archivo de origen a destino"""
+        import shutil
+        os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+        shutil.copy2(source_path, dest_path)
+        
+    def render_styles(self, styles: Dict[str, Any]) -> str:
+        """Convierte un diccionario de estilos a CSS"""
+        if not styles:
+            return ""
+            
+        css_rules = []
+        for property_name, value in styles.items():
+            # Convertir snake_case a kebab-case
+            css_property = property_name.replace('_', '-')
+            css_rules.append(f"{css_property}: {value}")
+            
+        return "; ".join(css_rules)
+        
+    def generate_unique_id(self, component: 'Component') -> str:
+        """Genera un ID único para un componente si no tiene uno"""
+        if component.id:
+            return component.id
+        return f"component_{id(component)}"
+