Struct Hooks 

pub struct Hooks<S: 'static> { /* private fields */ }

Effect collector for declarative lifecycle management.

Components receive a Hooks instance in their lifecycle method and use it to declare effects. The framework calls lifecycle after every build and update, clearing old effects and applying the new set — so effects are always consistent with current props and state.

Available hooks

Hook	Fires when
use_interval	Periodically, at the given duration
use_mount	Once, after the component is first built
use_unmount	Once, when the component is removed
use_autofocus	Requests focus when the component mounts
use_focus_scope	Creates a focus scope boundary for Tab cycling
provide_context	Makes a value available to descendants
use_context	Reads a value provided by an ancestor

Example

fn lifecycle(&self, hooks: &mut Hooks<TimerState>, state: &TimerState) {
    if self.running {
        hooks.use_interval(Duration::from_secs(1), |s| s.elapsed += 1);
    }
    hooks.use_mount(|s| s.started_at = Instant::now());
    hooks.use_unmount(|s| println!("ran for {:?}", s.started_at.elapsed()));
}

Implementations

impl<S: Send + Sync + 'static> Hooks<S>

pub fn use_interval( &mut self, interval: Duration, handler: impl Fn(&mut S) + Send + Sync + 'static, )

Register a periodic interval effect.

The handler is called each time interval elapses during the framework’s tick cycle. The handler receives &mut State and any mutations automatically mark the component dirty.

Commonly used for animations (e.g., the built-in Spinner uses an 80ms interval to cycle frames).

Examples found in repository

examples/chat.rs (lines 215-217)

    fn lifecycle(&self, hooks: &mut Hooks<StreamingDotsState>, _state: &StreamingDotsState) {
        hooks.use_interval(Duration::from_millis(300), |s| {
            s.frame = s.frame.wrapping_add(1);
        });
    }

pub fn use_mount(&mut self, handler: impl Fn(&mut S) + Send + Sync + 'static)

Register a mount effect that fires once after the component is built.

Use this for one-time initialization that depends on state being available (e.g., recording a start time, fetching initial data).

Examples found in repository

examples/lifecycle.rs (lines 81-88)

    fn lifecycle(&self, hooks: &mut Hooks<StatusLogState>, _state: &StatusLogState) {
        if !self.name.is_empty() {
            let mount_name = self.name.clone();
            hooks.use_mount(move |state| {
                state.log(
                    format!("  {} mounted", mount_name),
                    Style::default()
                        .fg(Color::Green)
                        .add_modifier(Modifier::ITALIC),
                );
            });

            let unmount_name = self.name.clone();
            hooks.use_unmount(move |state| {
                state.log(
                    format!("  {} unmounted", unmount_name),
                    Style::default()
                        .fg(Color::Red)
                        .add_modifier(Modifier::ITALIC),
                );
            });
        }
    }

pub fn use_unmount(&mut self, handler: impl Fn(&mut S) + Send + Sync + 'static)

Register an unmount effect that fires when the component is removed from the tree.

Use this for cleanup: logging, cancelling external resources, etc.

Examples found in repository

examples/lifecycle.rs (lines 91-98)

    fn lifecycle(&self, hooks: &mut Hooks<StatusLogState>, _state: &StatusLogState) {
        if !self.name.is_empty() {
            let mount_name = self.name.clone();
            hooks.use_mount(move |state| {
                state.log(
                    format!("  {} mounted", mount_name),
                    Style::default()
                        .fg(Color::Green)
                        .add_modifier(Modifier::ITALIC),
                );
            });

            let unmount_name = self.name.clone();
            hooks.use_unmount(move |state| {
                state.log(
                    format!("  {} unmounted", unmount_name),
                    Style::default()
                        .fg(Color::Red)
                        .add_modifier(Modifier::ITALIC),
                );
            });
        }
    }

pub fn use_autofocus(&mut self)

Request focus when this node mounts.

If multiple nodes mount with autofocus in the same rebuild, the last one wins.

Examples found in repository

examples/chat.rs (line 84)

    fn lifecycle(&self, hooks: &mut Hooks<Self::State>, _state: &Self::State) {
        hooks.use_autofocus();
    }

pub fn use_focus_scope(&mut self)

Mark this node as a focus scope boundary.

Tab/Shift-Tab cycling is confined to focusable descendants within this scope. Scopes nest — the deepest enclosing scope wins. When this node is removed from the tree, focus is restored to whatever was focused before the scope captured it.

pub fn provide_context<T: Any + Send + Sync>(&mut self, value: T)

Provide a context value to all descendant components.

The value is available during this reconciliation pass to any descendant that calls use_context with the same type T. If an ancestor already provides T, this component’s value shadows it for the subtree.

Example

fn lifecycle(&self, hooks: &mut Hooks<MyState>, _state: &MyState) {
    hooks.provide_context(self.event_sender.clone());
}

pub fn use_context<T: Any + Send + Sync + 'static>( &mut self, handler: impl FnOnce(Option<&T>, &mut Tracked<S>) + Send + 'static, )

Read a context value provided by an ancestor component.

The handler is called with Option<&T> (the context value, or None if no ancestor provides T) and &mut Tracked<S> (the component’s mutable state). The handler always fires — use the Option to handle the absent case.

The handler runs during reconciliation, after the component’s lifecycle method returns.

Example

fn lifecycle(&self, hooks: &mut Hooks<MyState>, _state: &MyState) {
    hooks.use_context::<Sender<AppEvent>>(|sender, state| {
        state.tx = sender.cloned();
    });
}