Struct RouterDeepLinks 

pub struct RouterDeepLinks<State: 'static> { /* private fields */ }

Router ⇄ deep-link auto-wiring: router_with_deep_links/ RouterDeepLinks resolve a Router’s start location from the process’s cold-start deep link (falling back to an app-supplied default) and keep navigating it on every subsequent warm link — see RouterDeepLinks’s doc for the precedence and dedupe contracts. This is the ONLY place in the facade that sees both frust-widgets’ Router and frust-reactive‘s deep-link source together; neither underlying crate depends on the other. Router ⇄ deep-link auto-wiring: router_with_deep_links/ RouterDeepLinks resolve a Router’s start location from the process’s cold-start deep link (falling back to an app-supplied default) and keep navigating it on every subsequent warm link — see RouterDeepLinks’s doc for the precedence and dedupe contracts. This is the ONLY place in the facade that sees both frust-widgets’ Router and frust-reactive‘s deep-link source together; neither underlying crate depends on the other. Router ⇄ deep-link auto-wiring: router_with_deep_links/ RouterDeepLinks resolve a Router’s start location from the process’s cold-start deep link (falling back to an app-supplied default) and keep navigating it on every subsequent warm link — see RouterDeepLinks’s doc for the precedence and dedupe contracts. This is the ONLY place in the facade that sees both frust-widgets’ Router and frust-reactive’s deep-link source together; neither underlying crate depends on the other. A Router wired to the process-wide deep-link source (see the module docs). Construct once with router_with_deep_links (or RouterDeepLinks::new directly) — typically from Component::init, storing the result in Component::State — then call track from every Component::build to keep navigating on subsequent warm links.

Implementations

impl<State: 'static> RouterDeepLinks<State>

pub fn new(router: Router<State>, initial_location: &str) -> Self

Wire router to the deep-link source and resolve its start location once: the process’s cold-start link if one has already arrived (see DeepLinks::initial), else initial_location (see the module docs’ precedence). Drives router there immediately via Router::handle_location.

Call this exactly once per router instance (e.g. from Component::init) — calling it again re-navigates to the start location, discarding whatever the app already navigated to since.

pub fn track(&self)

Apply everything queued on the router’s RouteNavigator, then track the live deep-link signal and navigate the router to any link that hasn’t been consumed yet. Call from every Component::build — the pump is idempotent on an empty queue, and the link half is dedup’d by a consumed marker (see the module docs), so a rebuild re-run that observes the same already-handled link is a no-op: no re-navigation, no panic even on a malformed/unmatched link (routed to the router’s error page like any other unmatched location).

Pumping first is what makes a queued request zero-frame: build runs before the navigator’s own rebuild, so the controller ops this enqueues are drained in that very same reconcile pass.

pub fn router(&self) -> &Router<State>

The wired router — hand its controller() to navigator, or call its navigation methods directly.

pub fn route_navigator(&self) -> RouteNavigator

The router’s RouteNavigator, waker already installed. Send + Sync and cheap to clone, so a Component::init can publish it once (provide_context(state.nav.route_navigator())) and any screen — or background task — navigates by path without holding the router:

let nav = use_context::<RouteNavigator>().expect("provided at the root");
button("Open", move |_| nav.push("/terminal?session=abc"));

Requests land on the next track.

pub fn routes(&self) -> RouteObserver

The route-state observable wired to this router — attach it to the router-driven navigator with .observe(navigator(links.router().controller(), ...)):

state.router_links.routes().observe(navigator(&c, initial))

Copy, so calling this more than once (or storing the result alongside route_navigator(), e.g. under provide_context) hands out clones of the same signals — reads through any of them see the same published state.