hypen_engine/reconcile/

tree.rs

use crate::ir::{Element, NodeId, Value};
use indexmap::IndexMap;
use slotmap::SlotMap;

/// Instance node - a concrete instance of an element in the tree
#[derive(Debug, Clone)]
pub struct InstanceNode {
    /// Unique node ID
    pub id: NodeId,

    /// Element type (e.g., "Column", "Text")
    pub element_type: String,

    /// Resolved props (bindings evaluated to actual values)
    pub props: IndexMap<String, serde_json::Value>,

    /// Raw props (including bindings) for change detection
    pub raw_props: IndexMap<String, Value>,

    /// Original element template (for List re-rendering)
    /// Only populated for List elements that need to re-render children
    pub element_template: Option<Element>,

    // Event handling removed - now done at renderer level

    /// Optional key for reconciliation
    pub key: Option<String>,

    /// Parent node ID
    pub parent: Option<NodeId>,

    /// Child node IDs (ordered)
    pub children: Vec<NodeId>,
}

impl InstanceNode {
    pub fn new(id: NodeId, element: &Element, state: &serde_json::Value) -> Self {
        let props = resolve_props(&element.props, state);

        Self {
            id,
            element_type: element.element_type.clone(),
            props,
            raw_props: element.props.clone(),
            element_template: None,
            key: element.key.clone(),
            parent: None,
            children: Vec::new(),
        }
    }

    /// Update props by re-evaluating bindings against new state
    pub fn update_props(&mut self, state: &serde_json::Value) {
        self.props = resolve_props(&self.raw_props, state);
    }
}

/// The instance tree - maintains the current UI tree state
pub struct InstanceTree {
    /// All nodes in the tree
    nodes: SlotMap<NodeId, InstanceNode>,

    /// Root node ID
    root: Option<NodeId>,
}

impl InstanceTree {
    pub fn new() -> Self {
        Self {
            nodes: SlotMap::with_key(),
            root: None,
        }
    }

    /// Clear all nodes and reset the tree
    pub fn clear(&mut self) {
        self.nodes.clear();
        self.root = None;
    }

    /// Create a new node and return its ID
    pub fn create_node(&mut self, element: &Element, state: &serde_json::Value) -> NodeId {
        let id = self.nodes.insert_with_key(|id| InstanceNode::new(id, element, state));
        id
    }

    /// Get a node by ID
    pub fn get(&self, id: NodeId) -> Option<&InstanceNode> {
        self.nodes.get(id)
    }

    /// Get a mutable node by ID
    pub fn get_mut(&mut self, id: NodeId) -> Option<&mut InstanceNode> {
        self.nodes.get_mut(id)
    }

    /// Remove a node and all its descendants
    pub fn remove(&mut self, id: NodeId) -> Option<InstanceNode> {
        if let Some(node) = self.nodes.get(id) {
            let children = node.children.clone();
            // Remove all children recursively
            for child_id in children {
                self.remove(child_id);
            }
        }
        self.nodes.remove(id)
    }

    /// Set the root node
    pub fn set_root(&mut self, id: NodeId) {
        self.root = Some(id);
    }

    /// Get the root node ID
    pub fn root(&self) -> Option<NodeId> {
        self.root
    }

    /// Add a child to a parent node
    pub fn add_child(&mut self, parent_id: NodeId, child_id: NodeId, before: Option<NodeId>) {
        if let Some(parent) = self.nodes.get_mut(parent_id) {
            if let Some(before_id) = before {
                if let Some(pos) = parent.children.iter().position(|&id| id == before_id) {
                    parent.children.insert(pos, child_id);
                } else {
                    parent.children.push(child_id);
                }
            } else {
                parent.children.push(child_id);
            }
        }

        if let Some(child) = self.nodes.get_mut(child_id) {
            child.parent = Some(parent_id);
        }
    }

    /// Remove a child from its parent
    pub fn remove_child(&mut self, parent_id: NodeId, child_id: NodeId) {
        if let Some(parent) = self.nodes.get_mut(parent_id) {
            parent.children.retain(|&id| id != child_id);
        }

        if let Some(child) = self.nodes.get_mut(child_id) {
            child.parent = None;
        }
    }

    /// Update all nodes that depend on changed state
    pub fn update_nodes(&mut self, node_ids: &indexmap::IndexSet<NodeId>, state: &serde_json::Value) {
        for &node_id in node_ids {
            if let Some(node) = self.nodes.get_mut(node_id) {
                node.update_props(state);
            }
        }
    }

    /// Iterate over all nodes
    pub fn iter(&self) -> impl Iterator<Item = (NodeId, &InstanceNode)> {
        self.nodes.iter()
    }
}

impl Default for InstanceTree {
    fn default() -> Self {
        Self::new()
    }
}

/// Resolve props by evaluating bindings against current state
fn resolve_props(props: &IndexMap<String, Value>, state: &serde_json::Value) -> IndexMap<String, serde_json::Value> {
    let mut resolved = IndexMap::new();

    for (key, value) in props {
        let resolved_value = match value {
            Value::Static(v) => v.clone(),
            Value::Binding(binding) => {
                // Evaluate binding against state using the parsed path
                evaluate_binding(binding, state).unwrap_or(serde_json::Value::Null)
            }
            Value::TemplateString { template, bindings } => {
                // Interpolate all bindings in the template string
                let mut result = template.clone();
                for binding in bindings {
                    let binding_placeholder = format!("${{state.{}}}", binding.full_path());
                    let value = evaluate_binding(binding, state)
                        .map(|v| match v {
                            serde_json::Value::String(s) => s,
                            other => other.to_string(),
                        })
                        .unwrap_or_default();
                    result = result.replace(&binding_placeholder, &value);
                }
                serde_json::Value::String(result)
            }
            Value::Action(action) => {
                // Actions are serialized with @ prefix for renderer to detect
                serde_json::Value::String(format!("@{}", action))
            }
        };
        resolved.insert(key.clone(), resolved_value);
    }

    resolved
}

/// Evaluate a binding against the state object using its parsed path
fn evaluate_binding(binding: &crate::reactive::Binding, state: &serde_json::Value) -> Option<serde_json::Value> {
    let mut current = state;

    for segment in &binding.path {
        current = current.get(segment)?;
    }

    Some(current.clone())
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn test_evaluate_binding() {
        use crate::reactive::Binding;

        let state = json!({
            "user": {
                "name": "Alice",
                "age": 30
            }
        });

        let name_binding = Binding::new(vec!["user".to_string(), "name".to_string()]);
        let age_binding = Binding::new(vec!["user".to_string(), "age".to_string()]);
        let email_binding = Binding::new(vec!["user".to_string(), "email".to_string()]);

        assert_eq!(
            evaluate_binding(&name_binding, &state),
            Some(json!("Alice"))
        );
        assert_eq!(
            evaluate_binding(&age_binding, &state),
            Some(json!(30))
        );
        assert_eq!(evaluate_binding(&email_binding, &state), None);
    }
}