teloce-py 0.1.0__py3-none-any.whl

teloce/__init__.py

@@ -0,0 +1,17 @@
+"""
+Teloce-Py - A Python compiler for Teloce .vel Single File Components
+
+Teloce-Py transforms .vel files into self-contained vanilla JavaScript
+without requiring Node.js, npm, or a CDN.
+"""
+
+from teloce.version import __version__
+
+__all__ = [
+    "__version__",
+    "compile",
+    "compile_file",
+    "compile_project",
+]
+
+from teloce.compiler.compiler import compile, compile_file, compile_project

teloce/__main__.py

@@ -0,0 +1,13 @@
+"""
+Teloce-Py command-line entry point.
+
+Usage:
+    python -m teloce [command] [options]
+"""
+
+import sys
+
+from teloce.cli.main import main
+
+if __name__ == "__main__":
+    sys.exit(main())

teloce/ast/__init__.py

@@ -0,0 +1,87 @@
+"""
+AST (Abstract Syntax Tree) package.
+
+Defines AST nodes for Teloce templates.
+"""
+
+from teloce.ast.nodes import (
+    ASTNode,
+    NodeType,
+    ElementNode,
+    TextNode,
+    InterpolationNode,
+    ForNode,
+    IfNode,
+    ElseNode,
+    EventNode,
+    BindingNode,
+    ComponentNode,
+    SlotNode,
+    FragmentNode,
+    AttributeNode,
+    CommentNode,
+    DoctypeNode,
+)
+
+from teloce.ast.expressions import (
+    ExpressionNode,
+    IdentifierNode,
+    LiteralNode,
+    BinaryNode,
+    UnaryNode,
+    CallNode,
+    MemberNode,
+)
+
+from teloce.ast.elements import (
+    ElementFactory,
+    VoidElement,
+    ContainerElement,
+)
+
+from teloce.ast.components import (
+    ComponentReference,
+    ComponentSlot,
+    ComponentProp,
+)
+
+from teloce.ast.visitors import (
+    ASTVisitor,
+    ASTTransformer,
+    ASTPrinter,
+)
+
+__all__ = [
+    "ASTNode",
+    "NodeType",
+    "ElementNode",
+    "TextNode",
+    "InterpolationNode",
+    "ForNode",
+    "IfNode",
+    "ElseNode",
+    "EventNode",
+    "BindingNode",
+    "ComponentNode",
+    "SlotNode",
+    "FragmentNode",
+    "AttributeNode",
+    "CommentNode",
+    "DoctypeNode",
+    "ExpressionNode",
+    "IdentifierNode",
+    "LiteralNode",
+    "BinaryNode",
+    "UnaryNode",
+    "CallNode",
+    "MemberNode",
+    "ElementFactory",
+    "VoidElement",
+    "ContainerElement",
+    "ComponentReference",
+    "ComponentSlot",
+    "ComponentProp",
+    "ASTVisitor",
+    "ASTTransformer",
+    "ASTPrinter",
+]

teloce/ast/components.py

@@ -0,0 +1,77 @@
+"""
+Component AST nodes.
+
+Defines nodes for custom components and component-related structures.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+
+from teloce.ast.nodes import ASTNode, NodeType
+
+
+@dataclass(init=False)
+class ComponentReference(ASTNode):
+    """
+    Reference to a custom component.
+    """
+    name: str
+    props: Dict[str, str] = field(default_factory=dict)
+    children: List[ASTNode] = field(default_factory=list)
+    slots: Dict[str, List[ASTNode]] = field(default_factory=dict)
+    
+    def __init__(self, name: str, props: Dict[str, str] = None,
+                 children: List[ASTNode] = None,
+                 slots: Dict[str, List[ASTNode]] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.COMPONENT, line, column)
+        self.name = name
+        self.props = props or {}
+        self.children = children or []
+        self.slots = slots or {}
+    
+    def accept(self, visitor):
+        return visitor.visit_component(self)
+
+
+@dataclass(init=False)
+class ComponentSlot(ASTNode):
+    """
+    Slot definition inside a component.
+    """
+    name: str = "default"
+    fallback: List[ASTNode] = field(default_factory=list)
+    
+    def __init__(self, name: str = "default", fallback: List[ASTNode] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.SLOT, line, column)
+        self.name = name
+        self.fallback = fallback or []
+    
+    def accept(self, visitor):
+        return visitor.visit_slot(self)
+
+
+@dataclass(init=False)
+class ComponentProp(ASTNode):
+    """
+    Prop definition for a component.
+    """
+    name: str
+    type: Optional[str] = None
+    required: bool = False
+    default: Any = None
+    validator: Optional[str] = None
+    
+    def __init__(self, name: str, type: str = None, required: bool = False,
+                 default: Any = None, validator: str = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.ATTRIBUTE, line, column)
+        self.name = name
+        self.type = type
+        self.required = required
+        self.default = default
+        self.validator = validator
+    
+    def accept(self, visitor):
+        return visitor.visit_attribute(self)

teloce/ast/elements.py

@@ -0,0 +1,84 @@
+"""
+Element factory and utilities.
+
+Provides utilities for creating and working with element nodes.
+"""
+
+from typing import List, Optional, Set
+
+from teloce.ast.nodes import ElementNode
+
+
+# HTML void elements (self-closing)
+VOID_ELEMENTS = {
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+    'command', 'keygen', 'menuitem'
+}
+
+# Container elements (can have children)
+CONTAINER_ELEMENTS = {
+    'div', 'span', 'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    'a', 'button', 'form', 'input', 'label', 'select', 'textarea',
+    'ul', 'ol', 'li', 'table', 'tr', 'td', 'th', 'thead', 'tbody',
+    'section', 'article', 'header', 'footer', 'nav', 'main', 'aside',
+    'figure', 'figcaption', 'blockquote', 'pre', 'code', 'em', 'strong',
+    'i', 'b', 'u', 's', 'small', 'mark', 'del', 'ins', 'sub', 'sup',
+    'iframe', 'video', 'audio', 'canvas', 'svg', 'template'
+}
+
+
+class ElementFactory:
+    """
+    Factory for creating element nodes.
+    """
+    
+    @staticmethod
+    def is_void(tag: str) -> bool:
+        """Check if a tag is a void element."""
+        return tag.lower() in VOID_ELEMENTS
+    
+    @staticmethod
+    def is_container(tag: str) -> bool:
+        """Check if a tag is a container element."""
+        return tag.lower() in CONTAINER_ELEMENTS or tag.lower() not in VOID_ELEMENTS
+    
+    @staticmethod
+    def create(tag: str, attributes: dict = None,
+               children: List = None, line: int = 0, column: int = 0) -> ElementNode:
+        """Create an element node."""
+        return ElementNode(tag, attributes, children=children or [], line=line, column=column)
+    
+    @staticmethod
+    def create_void(tag: str, attributes: dict = None,
+                    line: int = 0, column: int = 0) -> ElementNode:
+        """Create a void (self-closing) element."""
+        return ElementNode(tag, attributes, children=[], line=line, column=column)
+
+
+class VoidElement:
+    """
+    Represents a void (self-closing) HTML element.
+    """
+    
+    @staticmethod
+    def is_void(tag: str) -> bool:
+        return tag.lower() in VOID_ELEMENTS
+    
+    @staticmethod
+    def get_all() -> Set[str]:
+        return VOID_ELEMENTS.copy()
+
+
+class ContainerElement:
+    """
+    Represents a container HTML element that can have children.
+    """
+    
+    @staticmethod
+    def is_container(tag: str) -> bool:
+        return tag.lower() in CONTAINER_ELEMENTS or tag.lower() not in VOID_ELEMENTS
+    
+    @staticmethod
+    def get_all() -> Set[str]:
+        return CONTAINER_ELEMENTS.copy()

teloce/ast/expressions.py

@@ -0,0 +1,151 @@
+"""
+Expression AST nodes.
+
+Defines AST nodes for expressions used in templates.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, Any
+from enum import Enum, auto
+
+
+class ExpressionType(Enum):
+    """Types of expression nodes."""
+    IDENTIFIER = auto()
+    LITERAL = auto()
+    BINARY = auto()
+    UNARY = auto()
+    CALL = auto()
+    MEMBER = auto()
+    ARRAY = auto()
+    OBJECT = auto()
+
+
+@dataclass
+class ExpressionNode:
+    """Base class for expression nodes."""
+    type: ExpressionType
+    line: int = 0
+    column: int = 0
+
+
+@dataclass(init=False)
+class IdentifierNode(ExpressionNode):
+    """Identifier expression node."""
+    name: str
+    
+    def __init__(self, name: str, line: int = 0, column: int = 0):
+        super().__init__(ExpressionType.IDENTIFIER, line, column)
+        self.name = name
+    
+    def __repr__(self) -> str:
+        return f"Identifier({self.name})"
+
+
+@dataclass(init=False)
+class LiteralNode(ExpressionNode):
+    """Literal value expression node."""
+    value: Any
+    
+    def __init__(self, value: Any, line: int = 0, column: int = 0):
+        super().__init__(ExpressionType.LITERAL, line, column)
+        self.value = value
+    
+    def __repr__(self) -> str:
+        return f"Literal({repr(self.value)})"
+
+
+@dataclass(init=False)
+class BinaryNode(ExpressionNode):
+    """Binary operation expression node."""
+    left: ExpressionNode
+    operator: str
+    right: ExpressionNode
+    
+    def __init__(self, left: ExpressionNode, operator: str,
+                 right: ExpressionNode, line: int = 0, column: int = 0):
+        super().__init__(ExpressionType.BINARY, line, column)
+        self.left = left
+        self.operator = operator
+        self.right = right
+    
+    def __repr__(self) -> str:
+        return f"Binary({self.left} {self.operator} {self.right})"
+
+
+@dataclass(init=False)
+class UnaryNode(ExpressionNode):
+    """Unary operation expression node."""
+    operator: str
+    operand: ExpressionNode
+    
+    def __init__(self, operator: str, operand: ExpressionNode,
+                 line: int = 0, column: int = 0):
+        super().__init__(ExpressionType.UNARY, line, column)
+        self.operator = operator
+        self.operand = operand
+    
+    def __repr__(self) -> str:
+        return f"Unary({self.operator}{self.operand})"
+
+
+@dataclass(init=False)
+class CallNode(ExpressionNode):
+    """Function call expression node."""
+    callee: ExpressionNode
+    arguments: List[ExpressionNode]
+    
+    def __init__(self, callee: ExpressionNode, arguments: List[ExpressionNode] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(ExpressionType.CALL, line, column)
+        self.callee = callee
+        self.arguments = arguments or []
+    
+    def __repr__(self) -> str:
+        return f"Call({self.callee}, {self.arguments})"
+
+
+@dataclass(init=False)
+class MemberNode(ExpressionNode):
+    """Member access expression node."""
+    object: ExpressionNode
+    property: str
+    computed: bool = False
+    
+    def __init__(self, object: ExpressionNode, property: str,
+                 computed: bool = False, line: int = 0, column: int = 0):
+        super().__init__(ExpressionType.MEMBER, line, column)
+        self.object = object
+        self.property = property
+        self.computed = computed
+    
+    def __repr__(self) -> str:
+        return f"Member({self.object}.{self.property})"
+
+
+@dataclass(init=False)
+class ArrayNode(ExpressionNode):
+    """Array literal expression node."""
+    elements: List[ExpressionNode]
+    
+    def __init__(self, elements: List[ExpressionNode] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(ExpressionType.ARRAY, line, column)
+        self.elements = elements or []
+    
+    def __repr__(self) -> str:
+        return f"Array({self.elements})"
+
+
+@dataclass(init=False)
+class ObjectNode(ExpressionNode):
+    """Object literal expression node."""
+    properties: List[tuple]
+    
+    def __init__(self, properties: List[tuple] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(ExpressionType.OBJECT, line, column)
+        self.properties = properties or []
+    
+    def __repr__(self) -> str:
+        return f"Object({self.properties})"

teloce/ast/nodes.py

@@ -0,0 +1,271 @@
+"""
+AST node definitions for Teloce templates.
+
+Defines all node types used in the Abstract Syntax Tree.
+"""
+
+from enum import Enum, auto
+from dataclasses import dataclass, field
+from typing import List, Optional, Any, Dict
+
+
+class NodeType(Enum):
+    """Types of AST nodes."""
+    ELEMENT = auto()
+    TEXT = auto()
+    INTERPOLATION = auto()
+    FOR = auto()
+    IF = auto()
+    ELSE = auto()
+    EVENT = auto()
+    BINDING = auto()
+    COMPONENT = auto()
+    SLOT = auto()
+    FRAGMENT = auto()
+    ATTRIBUTE = auto()
+    COMMENT = auto()
+    DOCTYPE = auto()
+
+
+@dataclass
+class ASTNode:
+    """Base class for all AST nodes."""
+    type: NodeType
+    line: int = 0
+    column: int = 0
+    
+    def accept(self, visitor):
+        """Accept a visitor."""
+        method_name = f"visit_{self.type.name.lower()}"
+        method = getattr(visitor, method_name, None)
+        if method:
+            return method(self)
+        return visitor.visit_default(self)
+
+
+@dataclass(init=False)
+class ElementNode(ASTNode):
+    """HTML element node."""
+    tag: str
+    attributes: Dict[str, str] = field(default_factory=dict)
+    events: List['EventNode'] = field(default_factory=list)
+    bindings: List['BindingNode'] = field(default_factory=list)
+    children: List[ASTNode] = field(default_factory=list)
+    
+    def __init__(self, tag: str, attributes: Dict[str, str] = None,
+                 events: List['EventNode'] = None,
+                 bindings: List['BindingNode'] = None,
+                 children: List[ASTNode] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.ELEMENT, line, column)
+        self.tag = tag
+        self.attributes = attributes or {}
+        self.events = events or []
+        self.bindings = bindings or []
+        self.children = children or []
+    
+    def accept(self, visitor):
+        return visitor.visit_element(self)
+
+
+@dataclass(init=False)
+class TextNode(ASTNode):
+    """Plain text node."""
+    value: str
+    
+    def __init__(self, value: str, line: int = 0, column: int = 0):
+        super().__init__(NodeType.TEXT, line, column)
+        self.value = value
+    
+    def accept(self, visitor):
+        return visitor.visit_text(self)
+
+
+@dataclass(init=False)
+class InterpolationNode(ASTNode):
+    """{{ expression }} interpolation node."""
+    expression: str
+    
+    def __init__(self, expression: str, line: int = 0, column: int = 0):
+        super().__init__(NodeType.INTERPOLATION, line, column)
+        self.expression = expression
+    
+    def accept(self, visitor):
+        return visitor.visit_interpolation(self)
+
+
+@dataclass(init=False)
+class ForNode(ASTNode):
+    """For loop directive node."""
+    item: str
+    collection: str
+    key: str = ""
+    children: List[ASTNode] = field(default_factory=list)
+    
+    def __init__(self, item: str, collection: str, key: str = "",
+                 children: List[ASTNode] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.FOR, line, column)
+        self.item = item
+        self.collection = collection
+        self.key = key
+        self.children = children or []
+    
+    def accept(self, visitor):
+        return visitor.visit_for(self)
+
+
+@dataclass(init=False)
+class IfNode(ASTNode):
+    """If directive node."""
+    condition: str
+    children: List[ASTNode] = field(default_factory=list)
+    else_children: List[ASTNode] = field(default_factory=list)
+    
+    def __init__(self, condition: str, children: List[ASTNode] = None,
+                 else_children: List[ASTNode] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.IF, line, column)
+        self.condition = condition
+        self.children = children or []
+        self.else_children = else_children or []
+    
+    def accept(self, visitor):
+        return visitor.visit_if(self)
+
+
+@dataclass(init=False)
+class ElseNode(ASTNode):
+    """Else directive node."""
+    children: List[ASTNode] = field(default_factory=list)
+    
+    def __init__(self, children: List[ASTNode] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.ELSE, line, column)
+        self.children = children or []
+    
+    def accept(self, visitor):
+        return visitor.visit_else(self)
+
+
+@dataclass(init=False)
+class EventNode(ASTNode):
+    """@click event binding node."""
+    name: str
+    handler: str
+    
+    def __init__(self, name: str, handler: str, line: int = 0, column: int = 0):
+        super().__init__(NodeType.EVENT, line, column)
+        self.name = name
+        self.handler = handler
+    
+    def accept(self, visitor):
+        return visitor.visit_event(self)
+
+
+@dataclass(init=False)
+class BindingNode(ASTNode):
+    """:model binding node."""
+    name: str
+    value: str
+    
+    def __init__(self, name: str, value: str, line: int = 0, column: int = 0):
+        super().__init__(NodeType.BINDING, line, column)
+        self.name = name
+        self.value = value
+    
+    def accept(self, visitor):
+        return visitor.visit_binding(self)
+
+
+@dataclass(init=False)
+class ComponentNode(ASTNode):
+    """Custom component node."""
+    name: str
+    props: Dict[str, str] = field(default_factory=dict)
+    children: List[ASTNode] = field(default_factory=list)
+    slots: Dict[str, List[ASTNode]] = field(default_factory=dict)
+    
+    def __init__(self, name: str, props: Dict[str, str] = None,
+                 children: List[ASTNode] = None,
+                 slots: Dict[str, List[ASTNode]] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.COMPONENT, line, column)
+        self.name = name
+        self.props = props or {}
+        self.children = children or []
+        self.slots = slots or {}
+    
+    def accept(self, visitor):
+        return visitor.visit_component(self)
+
+
+@dataclass(init=False)
+class SlotNode(ASTNode):
+    """Slot node."""
+    name: str = "default"
+    children: List[ASTNode] = field(default_factory=list)
+    
+    def __init__(self, name: str = "default", children: List[ASTNode] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.SLOT, line, column)
+        self.name = name
+        self.children = children or []
+    
+    def accept(self, visitor):
+        return visitor.visit_slot(self)
+
+
+@dataclass(init=False)
+class FragmentNode(ASTNode):
+    """Fragment node (multiple root elements)."""
+    children: List[ASTNode] = field(default_factory=list)
+    
+    def __init__(self, children: List[ASTNode] = None,
+                 line: int = 0, column: int = 0):
+        super().__init__(NodeType.FRAGMENT, line, column)
+        self.children = children or []
+    
+    def accept(self, visitor):
+        return visitor.visit_fragment(self)
+
+
+@dataclass(init=False)
+class AttributeNode(ASTNode):
+    """HTML attribute node."""
+    name: str
+    value: str
+    
+    def __init__(self, name: str, value: str, line: int = 0, column: int = 0):
+        super().__init__(NodeType.ATTRIBUTE, line, column)
+        self.name = name
+        self.value = value
+    
+    def accept(self, visitor):
+        return visitor.visit_attribute(self)
+
+
+@dataclass(init=False)
+class CommentNode(ASTNode):
+    """HTML comment node."""
+    value: str
+    
+    def __init__(self, value: str, line: int = 0, column: int = 0):
+        super().__init__(NodeType.COMMENT, line, column)
+        self.value = value
+    
+    def accept(self, visitor):
+        return visitor.visit_comment(self)
+
+
+@dataclass(init=False)
+class DoctypeNode(ASTNode):
+    """DOCTYPE node."""
+    value: str
+    
+    def __init__(self, value: str, line: int = 0, column: int = 0):
+        super().__init__(NodeType.DOCTYPE, line, column)
+        self.value = value
+    
+    def accept(self, visitor):
+        return visitor.visit_doctype(self)