pyreact-framework 1.0.0__py3-none-any.whl

pyreact/dom/attributes.py

@@ -0,0 +1,317 @@
+"""
+Attributes Module
+=================
+
+This module handles mapping between HTML attributes and DOM properties.
+"""
+
+from typing import Any, Dict, Optional
+
+
+# HTML attributes that map to different DOM properties
+PROPERTY_NAMES: Dict[str, str] = {
+    'acceptCharset': 'accept-charset',
+    'accessKey': 'accesskey',
+    'allowFullScreen': 'allowfullscreen',
+    'autoComplete': 'autocomplete',
+    'autoFocus': 'autofocus',
+    'autoPlay': 'autoplay',
+    'cellPadding': 'cellpadding',
+    'cellSpacing': 'cellspacing',
+    'charSet': 'charset',
+    'className': 'class',
+    'colSpan': 'colspan',
+    'contentEditable': 'contenteditable',
+    'contextMenu': 'contextmenu',
+    'crossOrigin': 'crossorigin',
+    'dateTime': 'datetime',
+    'encType': 'enctype',
+    'formAction': 'formaction',
+    'formEncType': 'formenctype',
+    'formMethod': 'formmethod',
+    'formNoValidate': 'formnovalidate',
+    'formTarget': 'formtarget',
+    'frameBorder': 'frameborder',
+    'hrefLang': 'hreflang',
+    'htmlFor': 'for',
+    'httpEquiv': 'http-equiv',
+    'isMap': 'ismap',
+    'itemProp': 'itemprop',
+    'itemScope': 'itemscope',
+    'itemType': 'itemtype',
+    'keyParams': 'keyparams',
+    'keyType': 'keytype',
+    'marginHeight': 'marginheight',
+    'marginWidth': 'marginwidth',
+    'maxLength': 'maxlength',
+    'mediaGroup': 'mediagroup',
+    'noValidate': 'novalidate',
+    'playsInline': 'playsinline',
+    'radioGroup': 'radiogroup',
+    'readOnly': 'readonly',
+    'rowSpan': 'rowspan',
+    'spellCheck': 'spellcheck',
+    'srcDoc': 'srcdoc',
+    'srcLang': 'srclang',
+    'srcSet': 'srcset',
+    'tabIndex': 'tabindex',
+    'useMap': 'usemap',
+    'vocab': 'vocab',
+}
+
+# Reverse mapping
+ATTRIBUTE_NAMES = {v: k for k, v in PROPERTY_NAMES.items()}
+
+# Boolean attributes
+BOOLEAN_ATTRIBUTES = {
+    'allowfullscreen',
+    'async',
+    'autofocus',
+    'autoplay',
+    'checked',
+    'controls',
+    'default',
+    'defer',
+    'disabled',
+    'formnovalidate',
+    'hidden',
+    'ismap',
+    'itemscope',
+    'loop',
+    'multiple',
+    'muted',
+    'nomodule',
+    'novalidate',
+    'open',
+    'playsinline',
+    'readonly',
+    'required',
+    'reversed',
+    'selected',
+    'truespeed',
+}
+
+# Attributes that should be set as properties
+PROPERTIES = {
+    'value',
+    'checked',
+    'selected',
+    'selectedIndex',
+    'defaultValue',
+    'defaultChecked',
+}
+
+# Attributes with units
+UNITLESS_PROPERTIES = {
+    'animationIterationCount',
+    'borderImageOutset',
+    'borderImageSlice',
+    'borderImageWidth',
+    'boxFlex',
+    'boxFlexGroup',
+    'boxOrdinalGroup',
+    'columnCount',
+    'columns',
+    'flex',
+    'flexGrow',
+    'flexPositive',
+    'flexShrink',
+    'flexNegative',
+    'flexOrder',
+    'gridArea',
+    'gridColumn',
+    'gridColumnEnd',
+    'gridColumnStart',
+    'gridRow',
+    'gridRowEnd',
+    'gridRowStart',
+    'lineClamp',
+    'lineHeight',
+    'opacity',
+    'order',
+    'orphans',
+    'tabSize',
+    'widows',
+    'zIndex',
+    'zoom',
+    'fillOpacity',
+    'floodOpacity',
+    'stopOpacity',
+    'strokeDasharray',
+    'strokeDashoffset',
+    'strokeMiterlimit',
+    'strokeOpacity',
+    'strokeWidth',
+}
+
+
+def is_custom_attribute(name: str) -> bool:
+    """
+    Check if an attribute is custom (data-*, aria-*)
+    
+    Args:
+        name: Attribute name
+    
+    Returns:
+        bool: True if custom attribute
+    """
+    return name.startswith('data-') or name.startswith('aria-')
+
+
+def should_set_attribute(name: str, value: Any) -> bool:
+    """
+    Check if attribute should be set
+    
+    Args:
+        name: Attribute name
+        value: Attribute value
+    
+    Returns:
+        bool: True if should set
+    """
+    # Skip null/undefined
+    if value is None:
+        return False
+    
+    # Skip event handlers (handled separately)
+    if name.startswith('on'):
+        return False
+    
+    # Skip style (handled separately)
+    if name == 'style':
+        return False
+    
+    # Skip ref and key
+    if name in ('ref', 'key'):
+        return False
+    
+    return True
+
+
+def get_attribute_name(property_name: str) -> str:
+    """
+    Get HTML attribute name from DOM property name
+    
+    Args:
+        property_name: DOM property name
+    
+    Returns:
+        str: HTML attribute name
+    """
+    return PROPERTY_NAMES.get(property_name, property_name.lower())
+
+
+def get_property_name(attribute_name: str) -> str:
+    """
+    Get DOM property name from HTML attribute name
+    
+    Args:
+        attribute_name: HTML attribute name
+    
+    Returns:
+        str: DOM property name
+    """
+    return ATTRIBUTE_NAMES.get(attribute_name, attribute_name)
+
+
+def is_boolean_attribute(name: str) -> bool:
+    """
+    Check if attribute is boolean
+    
+    Args:
+        name: Attribute name
+    
+    Returns:
+        bool: True if boolean attribute
+    """
+    return name.lower() in BOOLEAN_ATTRIBUTES
+
+
+def is_property(name: str) -> bool:
+    """
+    Check if attribute should be set as a property
+    
+    Args:
+        name: Attribute name
+    
+    Returns:
+        bool: True if should be property
+    """
+    return name in PROPERTIES
+
+
+def get_style_value(name: str, value: Any) -> str:
+    """
+    Convert style value to string
+    
+    Args:
+        name: CSS property name
+        value: CSS value
+    
+    Returns:
+        str: Style string
+    """
+    if value is None or value == '':
+        return ''
+    
+    if isinstance(value, number):
+        if name not in UNITLESS_PROPERTIES:
+            return f"{value}px"
+        return str(value)
+    
+    return str(value)
+
+
+def escape_html_value(value: str) -> str:
+    """
+    Escape HTML special characters
+    
+    Args:
+        value: Value to escape
+    
+    Returns:
+        str: Escaped value
+    """
+    return (
+        str(value)
+        .replace('&', '&')
+        .replace('<', '&lt;')
+        .replace('>', '&gt;')
+        .replace('"', '&quot;')
+        .replace("'", '&#x27;')
+    )
+
+
+def render_attributes(props: Dict[str, Any]) -> str:
+    """
+    Render attributes as HTML string
+    
+    Args:
+        props: Props dictionary
+    
+    Returns:
+        str: HTML attribute string
+    """
+    result = []
+    
+    for name, value in props.items():
+        if not should_set_attribute(name, value):
+            continue
+        
+        attr_name = get_attribute_name(name)
+        
+        if is_boolean_attribute(attr_name):
+            if value:
+                result.append(attr_name)
+        else:
+            escaped = escape_html_value(value)
+            result.append(f'{attr_name}="{escaped}"')
+    
+    return ' '.join(result)
+
+
+# Number type check (for Python 2/3 compatibility)
+try:
+    number = (int, float)
+except NameError:
+    number = (int, float)

pyreact/dom/dom_operations.py

@@ -0,0 +1,333 @@
+"""
+DOM Operations Module
+=====================
+
+This module provides low-level DOM manipulation functions.
+These are platform-agnostic and can be adapted for different environments.
+"""
+
+from typing import Any, Callable, Dict, Optional
+
+
+# Platform-specific DOM implementation
+# In a real implementation, this would use a JavaScript bridge
+
+class DOMNode:
+    """Base class for DOM nodes"""
+    
+    def __init__(self, node_type: str):
+        self.node_type = node_type
+        self.parent_node: Optional['DOMNode'] = None
+        self.child_nodes: list = []
+    
+    def append_child(self, child: 'DOMNode') -> 'DOMNode':
+        """Append a child node"""
+        child.parent_node = self
+        self.child_nodes.append(child)
+        return child
+    
+    def remove_child(self, child: 'DOMNode') -> 'DOMNode':
+        """Remove a child node"""
+        if child in self.child_nodes:
+            child.parent_node = None
+            self.child_nodes.remove(child)
+        return child
+    
+    def insert_before(self, new_node: 'DOMNode', ref_node: Optional['DOMNode']) -> 'DOMNode':
+        """Insert a node before a reference node"""
+        new_node.parent_node = self
+        if ref_node is None:
+            self.child_nodes.append(new_node)
+        else:
+            index = self.child_nodes.index(ref_node)
+            self.child_nodes.insert(index, new_node)
+        return new_node
+
+
+class Element(DOMNode):
+    """DOM Element"""
+    
+    def __init__(self, tag_name: str):
+        super().__init__('element')
+        self.tag_name = tag_name.lower()
+        self.attributes: Dict[str, str] = {}
+        self.style: Dict[str, str] = {}
+        self._event_listeners: Dict[str, list] = {}
+        self._text_content: str = ''
+    
+    def set_attribute(self, name: str, value: str) -> None:
+        """Set an attribute"""
+        self.attributes[name] = value
+    
+    def get_attribute(self, name: str) -> Optional[str]:
+        """Get an attribute"""
+        return self.attributes.get(name)
+    
+    def remove_attribute(self, name: str) -> None:
+        """Remove an attribute"""
+        if name in self.attributes:
+            del self.attributes[name]
+    
+    def set_style(self, name: str, value: str) -> None:
+        """Set a style property"""
+        self.style[name] = value
+    
+    def add_event_listener(self, event_type: str, listener: Callable) -> None:
+        """Add an event listener"""
+        if event_type not in self._event_listeners:
+            self._event_listeners[event_type] = []
+        self._event_listeners[event_type].append(listener)
+    
+    def remove_event_listener(self, event_type: str, listener: Callable) -> None:
+        """Remove an event listener"""
+        if event_type in self._event_listeners:
+            if listener in self._event_listeners[event_type]:
+                self._event_listeners[event_type].remove(listener)
+    
+    def set_inner_html(self, html: str) -> None:
+        """Set inner HTML"""
+        self._text_content = html
+        self.child_nodes.clear()
+    
+    def insert_child(self, child: 'DOMNode', index: int) -> None:
+        """Insert a child at a specific index"""
+        child.parent_node = self
+        self.child_nodes.insert(index, child)
+    
+    def remove_child_at(self, index: int) -> None:
+        """Remove a child at a specific index"""
+        if 0 <= index < len(self.child_nodes):
+            child = self.child_nodes.pop(index)
+            child.parent_node = None
+    
+    def replace_child_at(self, new_child: 'DOMNode', index: int) -> None:
+        """Replace a child at a specific index"""
+        if 0 <= index < len(self.child_nodes):
+            old_child = self.child_nodes[index]
+            old_child.parent_node = None
+            new_child.parent_node = self
+            self.child_nodes[index] = new_child
+    
+    def move_child(self, old_index: int, new_index: int) -> None:
+        """Move a child from old_index to new_index"""
+        if 0 <= old_index < len(self.child_nodes) and 0 <= new_index < len(self.child_nodes):
+            child = self.child_nodes.pop(old_index)
+            self.child_nodes.insert(new_index, child)
+    
+    @property
+    def first_child(self) -> Optional['DOMNode']:
+        """Get first child"""
+        return self.child_nodes[0] if self.child_nodes else None
+    
+    @property
+    def inner_html(self) -> str:
+        """Get inner HTML"""
+        return self._text_content
+    
+    @inner_html.setter
+    def inner_html(self, value: str):
+        """Set inner HTML"""
+        self._text_content = value
+        self.child_nodes.clear()
+    
+    def get_element_by_id(self, id: str) -> Optional['Element']:
+        """Find element by ID"""
+        if self.attributes.get('id') == id:
+            return self
+        for child in self.child_nodes:
+            if isinstance(child, Element):
+                result = child.get_element_by_id(id)
+                if result:
+                    return result
+        return None
+    
+    def query_selector(self, selector: str) -> Optional['Element']:
+        """Query selector (simplified)"""
+        # Simplified implementation
+        for child in self.child_nodes:
+            if isinstance(child, Element):
+                if selector.startswith('#'):
+                    if child.attributes.get('id') == selector[1:]:
+                        return child
+                elif selector.startswith('.'):
+                    class_name = selector[1:]
+                    if class_name in child.attributes.get('class', '').split():
+                        return child
+                elif child.tag_name == selector.lower():
+                    return child
+        return None
+    
+    def query_selector_all(self, selector: str) -> list:
+        """Query all matching elements"""
+        results = []
+        for child in self.child_nodes:
+            if isinstance(child, Element):
+                if selector.startswith('#'):
+                    if child.attributes.get('id') == selector[1:]:
+                        results.append(child)
+                elif selector.startswith('.'):
+                    class_name = selector[1:]
+                    if class_name in child.attributes.get('class', '').split():
+                        results.append(child)
+                elif child.tag_name == selector.lower():
+                    results.append(child)
+                results.extend(child.query_selector_all(selector))
+        return results
+    
+    def focus(self) -> None:
+        """Focus the element"""
+        pass
+    
+    def blur(self) -> None:
+        """Blur the element"""
+        pass
+    
+    def click(self) -> None:
+        """Click the element"""
+        pass
+    
+    def scroll_into_view(self) -> None:
+        """Scroll element into view"""
+        pass
+    
+    def get_bounding_client_rect(self) -> Dict[str, float]:
+        """Get element dimensions"""
+        return {
+            'x': 0, 'y': 0,
+            'width': 0, 'height': 0,
+            'top': 0, 'right': 0,
+            'bottom': 0, 'left': 0
+        }
+    
+    def __repr__(self) -> str:
+        return f"<{self.tag_name}>"
+
+
+class TextNode(DOMNode):
+    """Text node"""
+    
+    def __init__(self, text: str):
+        super().__init__('text')
+        self.text_content = text
+    
+    def __repr__(self) -> str:
+        return f"#text: {self.text_content[:20]}..."
+
+
+class CommentNode(DOMNode):
+    """Comment node"""
+    
+    def __init__(self, text: str):
+        super().__init__('comment')
+        self.text_content = text
+
+
+class Document(Element):
+    """Document object"""
+    
+    def __init__(self):
+        super().__init__('html')
+        self.node_type = 'document'
+        self.body = Element('body')
+        self.head = Element('head')
+        self.append_child(self.head)
+        self.append_child(self.body)
+    
+    def create_element(self, tag_name: str) -> Element:
+        """Create an element"""
+        return Element(tag_name)
+    
+    def create_text_node(self, text: str) -> TextNode:
+        """Create a text node"""
+        return TextNode(text)
+    
+    def create_comment(self, text: str) -> CommentNode:
+        """Create a comment node"""
+        return CommentNode(text)
+    
+    def get_element_by_id(self, id: str) -> Optional[Element]:
+        """Find element by ID"""
+        return self.body.get_element_by_id(id)
+    
+    def query_selector(self, selector: str) -> Optional[Element]:
+        """Query selector"""
+        return self.body.query_selector(selector)
+    
+    def query_selector_all(self, selector: str) -> list:
+        """Query all matching elements"""
+        return self.body.query_selector_all(selector)
+
+
+# Global document instance
+document = Document()
+
+
+def create_element(tag_name: str) -> Element:
+    """Create a DOM element"""
+    return document.create_element(tag_name)
+
+
+def create_text_node(text: str) -> TextNode:
+    """Create a text node"""
+    return document.create_text_node(text)
+
+
+def append_child(parent: DOMNode, child: DOMNode) -> DOMNode:
+    """Append a child to a parent"""
+    return parent.append_child(child)
+
+
+def remove_child(parent: DOMNode, child: DOMNode) -> DOMNode:
+    """Remove a child from a parent"""
+    return parent.remove_child(child)
+
+
+def insert_before(parent: DOMNode, new_node: DOMNode, ref_node: Optional[DOMNode]) -> DOMNode:
+    """Insert a node before a reference node"""
+    return parent.insert_before(new_node, ref_node)
+
+
+def set_attribute(element: Element, name: str, value: str) -> None:
+    """Set an attribute on an element"""
+    element.attributes[name] = value
+
+
+def remove_attribute(element: Element, name: str) -> None:
+    """Remove an attribute from an element"""
+    if name in element.attributes:
+        del element.attributes[name]
+
+
+def set_style(element: Element, styles: Dict[str, str]) -> None:
+    """Set styles on an element"""
+    element.style.update(styles)
+
+
+def add_event_listener(
+    element: Element,
+    event_type: str,
+    listener: Callable,
+    options: Optional[Dict] = None
+) -> None:
+    """Add an event listener to an element"""
+    if event_type not in element._event_listeners:
+        element._event_listeners[event_type] = []
+    element._event_listeners[event_type].append(listener)
+
+
+def remove_event_listener(
+    element: Element,
+    event_type: str,
+    listener: Callable
+) -> None:
+    """Remove an event listener from an element"""
+    if event_type in element._event_listeners:
+        if listener in element._event_listeners[event_type]:
+            element._event_listeners[event_type].remove(listener)
+
+
+def dispatch_event(element: Element, event_type: str, event_data: Optional[Dict] = None) -> None:
+    """Dispatch an event on an element"""
+    if event_type in element._event_listeners:
+        for listener in element._event_listeners[event_type]:
+            listener(event_data or {})