Struct Engine 

pub struct Engine { /* private fields */ }

The main Hypen engine that orchestrates reactive UI rendering.

Architecture: Single Active Module

Each Engine instance has one “active” module at a time for state bindings. When DSL templates reference ${state.xxx}, they resolve against the active module’s state.

Multi-module Applications

Multi-module apps (e.g., AppState + StatsScreen) work as follows:

1. TypeScript SDK layer manages multiple HypenModuleInstance objects, each with its own Proxy-based state tracking.

2. Cross-module communication uses HypenGlobalContext:

   // In StatsScreen's action handler:
   const app = context.getModule<AppState>("app");
   app.setState({ showStats: true });

3. State binding scope: Each module’s template binds to its own state. You cannot reference another module’s state directly in templates. Use props or callbacks instead:

   // StatsScreen receives app data via props, not state binding
   StatsView(data: @props.appStats)

Limitation

The engine’s state binding model (${state.xxx}) is scoped to a single module. Cross-module state access requires explicit prop passing or action dispatching. This keeps the reactive graph simple but requires careful data flow design.

Implementations

impl Engine

pub fn new() -> Self

pub fn register_component(&mut self, component: Component)

Register a custom component

pub fn set_component_resolver<F>(&mut self, resolver: F)

where F: Fn(&str, Option<&str>) -> Option<ResolvedComponent> + Send + Sync + 'static,

Set the component resolver for dynamic component loading The resolver receives (component_name, context_path) and should return ResolvedComponent { source, path } or None

pub fn set_module(&mut self, module: ModuleInstance)

Set the module instance

pub fn set_render_callback<F>(&mut self, callback: F)

where F: Fn(&[Patch]) + Send + Sync + 'static,

Set the render callback

pub fn on_action<F>(&mut self, action_name: impl Into<String>, handler: F)

where F: Fn(&Action) + Send + Sync + 'static,

Register an action handler

pub fn render(&mut self, element: &Element)

Render an element tree (initial render or full re-render)

pub fn notify_state_change(&mut self, change: &StateChange)

Handle a state change notification from the module host The host keeps the actual state - we just need to know what changed

pub fn update_state(&mut self, state_patch: Value)

Convenience method for backward compatibility / JSON patches

pub fn dispatch_action(&mut self, action: Action) -> Result<(), EngineError>

Dispatch an action

pub fn revision(&self) -> u64

Get the current revision number

pub fn component_registry(&self) -> &ComponentRegistry

Get access to the component registry

pub fn component_registry_mut(&mut self) -> &mut ComponentRegistry

Get mutable access to the component registry

pub fn resources(&self) -> &ResourceCache

Get access to the resource cache

pub fn resources_mut(&mut self) -> &mut ResourceCache

Get mutable access to the resource cache

Trait Implementations

impl Default for Engine

fn default() -> Self

Returns the “default value” for a type.