Struct HookContext

Source

pub struct HookContext {
    pub inner: Rc<RefCell<HookContextInner>>,
}

Expand description

Manages hook state across render cycles for a DynamicNode.

Stores boxed Any values keyed by hook call order, enabling use_signal and similar hooks to persist state between re-renders of the same dynamic node.

Implements Clone for ergonomic use; all clones share the same underlying state.

Fields§

§inner: Rc<RefCell<HookContextInner>>

Shared reference to the heap-allocated hook context inner state.

Implementations§

Source §

impl HookContext

Implementation of hook context lifecycle and hook index management.

Source

pub fn reset_index(&mut self)

Resets the hook index for a new render cycle.

Sets the internal hook index back to zero so that subsequent use_signal calls start indexing from the beginning of the hook list.

Source

pub fn switch_arm(&mut self, changed: usize)

Notifies the hook context that a match arm is being entered.

If the arm index has changed, all existing hooks and cleanups are cleared and re-initialized for the new arm. If the arm is unchanged, only the hook index is reset.

§Arguments

usize - The index of the new match arm.

Source

pub fn noderef<T>() -> NodeRef<T>
where T: ?Sized + 'static,

Creates or reuses a NodeRef<T> at the current hook index.

On the first call at a given hook index, a fresh empty NodeRef is stored. On subsequent re-renders the same instance is returned, so a ref cloned into a closure stays attached to the live DOM element across renders.

The element type T is a phantom marker only — we downcast the stored Box<dyn Any> back to NodeRef<T> using the same pattern as Signal::signal above. Note that two calls at the same hook index with different T would still match (both are NodeRef<...>) because the downcast_ref ignores the phantom parameter.

§Returns

NodeRef<T> - A NodeRef<T> value.

Source §

impl HookContext

Associated functions for hook context management.

These are crate-internal static methods for managing the active hook context, creating signals, registering cleanups, and scheduling intervals.

Source

pub fn current() -> HookContext

Returns the currently active HookContext.

If no hook context has been set, creates and stores a default one in the global CURRENT_HOOK_CONTEXT cell so subsequent calls return the same instance.

§Returns

HookContext - The currently active hook context.

Source

pub fn with<F, R>(context: HookContext, callback: F) -> R
where F: FnOnce() -> R,

Runs a closure with the given HookContext set as the active context.

Saves the previous context, sets the new one, executes the closure, and restores the previous context afterward.

§Arguments

HookContext - The hook context to set as active during closure execution.
F: FnOnce() -> R - The closure to execute with the given context.

§Returns

R - The result of the closure execution.

Source

pub fn signal<T, F>(init: F) -> Signal<T>
where T: Clone + PartialEq + 'static, F: FnOnce() -> T,

Creates a new reactive signal with the given initial value.

Uses the current HookContext to maintain signal identity across re-renders. On the first call at a given hook index, the signal is created with init() and stored. On subsequent re-renders, the existing signal at that index is returned unchanged.

§Arguments

FnOnce() -> T - A closure that computes the initial value of the signal.

§Returns

Signal<T> - A reactive signal containing the initialized or existing value.

Source

pub fn cleanup<F>(cleanup: F)
where F: FnOnce() + 'static,

Registers a cleanup callback that will be executed when the current hook context is cleared (e.g., when a match arm switches).

This is useful for cleaning up side effects like intervals, timeouts, or subscriptions that are not automatically managed by signals.

The cleanup callback is only registered once on the first render. On subsequent re-renders at the same hook index, this is a no-op.

§Arguments

FnOnce() + 'static - The cleanup callback to execute on context teardown.

Source

pub fn window_event<E, F>(event_name: E, callback: F)
where E: AsRef<str>, F: FnMut() + 'static,

Registers a window.addEventListener callback using event delegation, automatically removed when the hook context is cleared.

Uses the global window event proxy registry so that only one window.addEventListener call is made per event name regardless of how many components listen to the same event. On cleanup, only the handler entry is removed from the proxy registry; the shared window listener remains active for other consumers.

The event listener is only registered once on the first render. On subsequent re-renders at the same hook index, this is a no-op.

§Arguments

E: AsRef<str> - The event name to listen for (e.g., “hashchange”, “popstate”, “resize”).
FnMut() + 'static - The callback to invoke when the event fires.

Source

pub fn interval<F>(millis: i32, callback: F) -> IntervalHandle
where F: FnMut() + 'static,

Creates a recurring interval that invokes the given closure at the specified period, returning an IntervalHandle that is automatically cleared when the hook context is cleared (i.e., when the component unmounts or a match arm switches).

Unlike calling set_interval_with_callback_and_timeout_and_arguments_0

Closure::forget() manually, this hook ensures the interval is properly cleaned up, preventing memory leaks and stale callbacks.

The interval is only created once on the first render. On subsequent re-renders at the same hook index, the existing handle is returned unchanged.

§Arguments

i32 - The interval period in milliseconds.
FnMut() + 'static - The closure to invoke on each interval tick.

§Returns

IntervalHandle - A handle that can be used to cancel the interval early.

§Panics

Panics if window() is unavailable on the current platform.

Source §

impl HookContext

Inherent implementation of HookContext.

Source

pub fn use_hook<T, F>(factory: F) -> T
where F: FnOnce() -> T, T: Clone + 'static,

Registers a hook value with the current hook context and returns the existing instance if one was stored at this index from a previous render cycle.

This is the public extension point for custom hook types. ui and downstream crates implement use_form, use_i18n, etc. on top of this primitive instead of poking at the hook array directly. factory runs once per hook slot on the first render; subsequent renders in the same arm return the previously stored instance.