Remove state param from lifecycle events

lucasmerlin · lucasmerlin · commit eeb43a9fc483 · 2026-02-10T21:58:14.000+01:00
diff --git a/crates/egui_router/examples/async_router.rs b/crates/egui_router/examples/async_router.rs
@@ -48,7 +48,7 @@ async fn main() -> eframe::Result<()> {
                     router.navigate(&mut sender, route).ok();
                 }
                 RouterMessage::Back => {
-                    router.back(&mut sender).ok();
+                    router.back().ok();
                 }
             });
 
diff --git a/crates/egui_router/examples/route_lifecycle.rs b/crates/egui_router/examples/route_lifecycle.rs
@@ -47,7 +47,7 @@ async fn main() -> eframe::Result<()> {
                     router.navigate(state, route).ok();
                 }
                 RouterMessage::Back => {
-                    router.back(state).ok();
+                    router.back().ok();
                 }
             });
 
@@ -103,19 +103,19 @@ impl Route<AppState> for HomePage {
         });
     }
 
-    fn on_showing(&mut self, _state: &mut AppState) {
+    fn on_showing(&mut self) {
         self.events.push("on_showing (transition back started)");
     }
 
-    fn on_shown(&mut self, _state: &mut AppState) {
+    fn on_shown(&mut self) {
         self.events.push("on_shown (fully visible)");
     }
 
-    fn on_hiding(&mut self, _state: &mut AppState) {
+    fn on_hiding(&mut self) {
         self.events.push("on_hiding (transition away started)");
     }
 
-    fn on_hide(&mut self, _state: &mut AppState) {
+    fn on_hide(&mut self) {
         self.events.push("on_hide (fully hidden)");
     }
 }
@@ -154,19 +154,19 @@ impl Route<AppState> for DetailPage {
         });
     }
 
-    fn on_showing(&mut self, _state: &mut AppState) {
+    fn on_showing(&mut self) {
         self.events.push("on_showing (transition back started)");
     }
 
-    fn on_shown(&mut self, _state: &mut AppState) {
+    fn on_shown(&mut self) {
         self.events.push("on_shown (fully visible)");
     }
 
-    fn on_hiding(&mut self, _state: &mut AppState) {
+    fn on_hiding(&mut self) {
         self.events.push("on_hiding (transition away started)");
     }
 
-    fn on_hide(&mut self, _state: &mut AppState) {
+    fn on_hide(&mut self) {
         self.events.push("on_hide (fully hidden)");
     }
 }
@@ -210,19 +210,19 @@ impl Route<AppState> for NoSwipePage {
         Some(false)
     }
 
-    fn on_showing(&mut self, _state: &mut AppState) {
+    fn on_showing(&mut self) {
         self.events.push("on_showing (transition back started)");
     }
 
-    fn on_shown(&mut self, _state: &mut AppState) {
+    fn on_shown(&mut self) {
         self.events.push("on_shown (fully visible)");
     }
 
-    fn on_hiding(&mut self, _state: &mut AppState) {
+    fn on_hiding(&mut self) {
         self.events.push("on_hiding (transition away started)");
     }
 
-    fn on_hide(&mut self, _state: &mut AppState) {
+    fn on_hide(&mut self) {
         self.events.push("on_hide (fully hidden)");
     }
 }
diff --git a/crates/egui_router/examples/router.rs b/crates/egui_router/examples/router.rs
@@ -56,7 +56,7 @@ async fn main() -> eframe::Result<()> {
                             state.0.navigate(&mut state.1, route).unwrap();
                         }
                         RouterMessage::Back => {
-                            state.0.back(&mut state.1).unwrap();
+                            state.0.back().unwrap();
                         }
                     });
             }
diff --git a/crates/egui_router/examples/router_minimal.rs b/crates/egui_router/examples/router_minimal.rs
@@ -34,7 +34,7 @@ async fn main() -> eframe::Result<()> {
                     router.navigate(&mut inbox, route).ok();
                 }
                 RouterMessage::Back => {
-                    router.back(&mut inbox).ok();
+                    router.back().ok();
                 }
             });
 
diff --git a/crates/egui_router/src/lib.rs b/crates/egui_router/src/lib.rs
@@ -32,19 +32,19 @@ pub trait Route<State = ()> {
 
     /// Called when this route starts becoming visible again (transition starts).
     /// E.g., when a back navigation begins and this route starts animating in.
-    fn on_showing(&mut self, _state: &mut State) {}
+    fn on_showing(&mut self) {}
 
     /// Called when this route is fully visible (transition completes).
     /// E.g., when a back navigation finishes and this route is fully shown.
-    fn on_shown(&mut self, _state: &mut State) {}
+    fn on_shown(&mut self) {}
 
     /// Called when this route starts being hidden (transition starts).
     /// E.g., when a forward navigation begins and this route starts animating out.
-    fn on_hiding(&mut self, _state: &mut State) {}
+    fn on_hiding(&mut self) {}
 
     /// Called when this route is fully hidden (transition completes).
     /// E.g., when a forward navigation finishes and another route is now on top.
-    fn on_hide(&mut self, _state: &mut State) {}
+    fn on_hide(&mut self) {}
 
     /// Override the router's swipe-back gesture setting for this route.
     /// Return `Some(true)` to enable, `Some(false)` to disable, or `None` to
diff --git a/crates/egui_router/src/router.rs b/crates/egui_router/src/router.rs
@@ -142,14 +142,14 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {
                         if self.history.len() >= 2 {
                             let idx = self.history.len() - 2;
                             if let Ok(route) = &mut self.history[idx].route {
-                                route.on_hiding(state);
+                                route.on_hiding();
                             }
                         }
 
                         // Fire on_showing on the newly created route
                         if let Some(last) = self.history.last_mut() {
                             if let Ok(route) = &mut last.route {
-                                route.on_showing(state);
+                                route.on_showing();
                             }
                         }
 
@@ -198,21 +198,21 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {
         self.navigate_transition(state, route, self.forward_transition.clone())
     }
 
-    fn back_impl(&mut self, state: &mut State, transition_config: TransitionConfig) {
+    fn back_impl(&mut self, transition_config: TransitionConfig) {
         if self.history.len() > 1 {
             let mut leaving_route = self.history.pop();
 
             // Fire on_hiding on the leaving route
             if let Some(ref mut leaving) = leaving_route {
                 if let Ok(route) = &mut leaving.route {
-                    route.on_hiding(state);
+                    route.on_hiding();
                 }
             }
 
             // Fire on_showing on the route that is now being revealed
             if let Some(last) = self.history.last_mut() {
                 if let Ok(route) = &mut last.route {
-                    route.on_showing(state);
+                    route.on_showing();
                 }
             }
 
@@ -225,19 +225,15 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {
     }
 
     /// Go back with a custom transition
-    pub fn back_transition(
-        &mut self,
-        state: &mut State,
-        transition_config: TransitionConfig,
-    ) -> RouterResult {
+    pub fn back_transition(&mut self, transition_config: TransitionConfig) -> RouterResult {
         self.history_kind.back()?;
-        self.back_impl(state, transition_config);
+        self.back_impl(transition_config);
         Ok(())
     }
 
     /// Go back with the default transition
-    pub fn back(&mut self, state: &mut State) -> RouterResult {
-        self.back_transition(state, self.backward_transition.clone())
+    pub fn back(&mut self) -> RouterResult {
+        self.back_transition(self.backward_transition.clone())
     }
 
     /// Replace the current route with a custom transition
@@ -266,7 +262,7 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {
                     // Fire on_hiding on the leaving route
                     if let Some(ref mut leaving) = leaving_route {
                         if let Ok(route) = &mut leaving.route {
-                            route.on_hiding(state);
+                            route.on_hiding();
                         }
                     }
 
@@ -285,7 +281,7 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {
                     // Fire on_showing on the newly created route
                     if let Some(last) = self.history.last_mut() {
                         if let Ok(route) = &mut last.route {
-                            route.on_showing(state);
+                            route.on_showing();
                         }
                     }
 
@@ -349,7 +345,7 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {
                     .retain(|r| r.state <= route_state || r.state == active_state);
 
                 if route_state < active_state {
-                    self.back_impl(state, self.backward_transition.clone());
+                    self.back_impl(self.backward_transition.clone());
                 }
             } else {
                 self.navigate_impl(state, &path, self.forward_transition.clone(), state_index)
@@ -402,33 +398,33 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {
                             // Leaving route is fully hidden
                             if let Some(ref mut leaving) = transition.leaving_route {
                                 if let Ok(route) = &mut leaving.route {
-                                    route.on_hide(state);
+                                    route.on_hide();
                                 }
                             }
                             // Current top is fully shown again
                             if let Some(last) = self.history.last_mut() {
                                 if let Ok(route) = &mut last.route {
-                                    route.on_shown(state);
+                                    route.on_shown();
                                 }
                             }
                         } else {
                             // Forward/replace completed
                             if let Some(ref mut leaving) = transition.leaving_route {
                                 // Replace: leaving route is fully hidden
                                 if let Ok(route) = &mut leaving.route {
-                                    route.on_hide(state);
+                                    route.on_hide();
                                 }
                             } else if self.history.len() >= 2 {
                                 // Forward: previous top is now fully hidden
                                 let idx = self.history.len() - 2;
                                 if let Ok(route) = &mut self.history[idx].route {
-                                    route.on_hide(state);
+                                    route.on_hide();
                                 }
                             }
                             // The new top route is now fully shown
                             if let Some(last) = self.history.last_mut() {
                                 if let Ok(route) = &mut last.route {
-                                    route.on_shown(state);
+                                    route.on_shown();
                                 }
                             }
                         }
@@ -561,14 +557,14 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {
                         // Fire on_hiding on the popped route
                         if let Some(ref mut leaving) = popped {
                             if let Ok(route) = &mut leaving.route {
-                                route.on_hiding(state);
+                                route.on_hiding();
                             }
                         }
 
                         // Fire on_showing on the route being revealed
                         if let Some(last) = self.history.last_mut() {
                             if let Ok(route) = &mut last.route {
-                                route.on_showing(state);
+                                route.on_showing();
                             }
                         }
 

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ async fn main() -> eframe::Result<()> {`
`48`	`48`	`router.navigate(&mut sender, route).ok();`
`49`	`49`	`}`
`50`	`50`	`RouterMessage::Back => {`
`51`		`- router.back(&mut sender).ok();`
	`51`	`+ router.back().ok();`
`52`	`52`	`}`
`53`	`53`	`});`
`54`	`54`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ async fn main() -> eframe::Result<()> {`
`47`	`47`	`router.navigate(state, route).ok();`
`48`	`48`	`}`
`49`	`49`	`RouterMessage::Back => {`
`50`		`- router.back(state).ok();`
	`50`	`+ router.back().ok();`
`51`	`51`	`}`
`52`	`52`	`});`
`53`	`53`
`@@ -103,19 +103,19 @@ impl Route<AppState> for HomePage {`
`103`	`103`	`});`
`104`	`104`	`}`
`105`	`105`
`106`		`- fn on_showing(&mut self, _state: &mut AppState) {`
	`106`	`+ fn on_showing(&mut self) {`
`107`	`107`	`self.events.push("on_showing (transition back started)");`
`108`	`108`	`}`
`109`	`109`
`110`		`- fn on_shown(&mut self, _state: &mut AppState) {`
	`110`	`+ fn on_shown(&mut self) {`
`111`	`111`	`self.events.push("on_shown (fully visible)");`
`112`	`112`	`}`
`113`	`113`
`114`		`- fn on_hiding(&mut self, _state: &mut AppState) {`
	`114`	`+ fn on_hiding(&mut self) {`
`115`	`115`	`self.events.push("on_hiding (transition away started)");`
`116`	`116`	`}`
`117`	`117`
`118`		`- fn on_hide(&mut self, _state: &mut AppState) {`
	`118`	`+ fn on_hide(&mut self) {`
`119`	`119`	`self.events.push("on_hide (fully hidden)");`
`120`	`120`	`}`
`121`	`121`	`}`
`@@ -154,19 +154,19 @@ impl Route<AppState> for DetailPage {`
`154`	`154`	`});`
`155`	`155`	`}`
`156`	`156`
`157`		`- fn on_showing(&mut self, _state: &mut AppState) {`
	`157`	`+ fn on_showing(&mut self) {`
`158`	`158`	`self.events.push("on_showing (transition back started)");`
`159`	`159`	`}`
`160`	`160`
`161`		`- fn on_shown(&mut self, _state: &mut AppState) {`
	`161`	`+ fn on_shown(&mut self) {`
`162`	`162`	`self.events.push("on_shown (fully visible)");`
`163`	`163`	`}`
`164`	`164`
`165`		`- fn on_hiding(&mut self, _state: &mut AppState) {`
	`165`	`+ fn on_hiding(&mut self) {`
`166`	`166`	`self.events.push("on_hiding (transition away started)");`
`167`	`167`	`}`
`168`	`168`
`169`		`- fn on_hide(&mut self, _state: &mut AppState) {`
	`169`	`+ fn on_hide(&mut self) {`
`170`	`170`	`self.events.push("on_hide (fully hidden)");`
`171`	`171`	`}`
`172`	`172`	`}`
`@@ -210,19 +210,19 @@ impl Route<AppState> for NoSwipePage {`
`210`	`210`	`Some(false)`
`211`	`211`	`}`
`212`	`212`
`213`		`- fn on_showing(&mut self, _state: &mut AppState) {`
	`213`	`+ fn on_showing(&mut self) {`
`214`	`214`	`self.events.push("on_showing (transition back started)");`
`215`	`215`	`}`
`216`	`216`
`217`		`- fn on_shown(&mut self, _state: &mut AppState) {`
	`217`	`+ fn on_shown(&mut self) {`
`218`	`218`	`self.events.push("on_shown (fully visible)");`
`219`	`219`	`}`
`220`	`220`
`221`		`- fn on_hiding(&mut self, _state: &mut AppState) {`
	`221`	`+ fn on_hiding(&mut self) {`
`222`	`222`	`self.events.push("on_hiding (transition away started)");`
`223`	`223`	`}`
`224`	`224`
`225`		`- fn on_hide(&mut self, _state: &mut AppState) {`
	`225`	`+ fn on_hide(&mut self) {`
`226`	`226`	`self.events.push("on_hide (fully hidden)");`
`227`	`227`	`}`
`228`	`228`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ async fn main() -> eframe::Result<()> {`
`56`	`56`	`state.0.navigate(&mut state.1, route).unwrap();`
`57`	`57`	`}`
`58`	`58`	`RouterMessage::Back => {`
`59`		`- state.0.back(&mut state.1).unwrap();`
	`59`	`+ state.0.back().unwrap();`
`60`	`60`	`}`
`61`	`61`	`});`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ async fn main() -> eframe::Result<()> {`
`34`	`34`	`router.navigate(&mut inbox, route).ok();`
`35`	`35`	`}`
`36`	`36`	`RouterMessage::Back => {`
`37`		`- router.back(&mut inbox).ok();`
	`37`	`+ router.back().ok();`
`38`	`38`	`}`
`39`	`39`	`});`
`40`	`40`
Original file line number	Diff line number	Diff line change
`@@ -142,14 +142,14 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {`
`142`	`142`	`if self.history.len() >= 2 {`
`143`	`143`	`let idx = self.history.len() - 2;`
`144`	`144`	`if let Ok(route) = &mut self.history[idx].route {`
`145`		`- route.on_hiding(state);`
	`145`	`+ route.on_hiding();`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`// Fire on_showing on the newly created route`
`150`	`150`	`if let Some(last) = self.history.last_mut() {`
`151`	`151`	`if let Ok(route) = &mut last.route {`
`152`		`- route.on_showing(state);`
	`152`	`+ route.on_showing();`
`153`	`153`	`}`
`154`	`154`	`}`
`155`	`155`
`@@ -198,21 +198,21 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {`
`198`	`198`	`self.navigate_transition(state, route, self.forward_transition.clone())`
`199`	`199`	`}`
`200`	`200`
`201`		`- fn back_impl(&mut self, state: &mut State, transition_config: TransitionConfig) {`
	`201`	`+ fn back_impl(&mut self, transition_config: TransitionConfig) {`
`202`	`202`	`if self.history.len() > 1 {`
`203`	`203`	`let mut leaving_route = self.history.pop();`
`204`	`204`
`205`	`205`	`// Fire on_hiding on the leaving route`
`206`	`206`	`if let Some(ref mut leaving) = leaving_route {`
`207`	`207`	`if let Ok(route) = &mut leaving.route {`
`208`		`- route.on_hiding(state);`
	`208`	`+ route.on_hiding();`
`209`	`209`	`}`
`210`	`210`	`}`
`211`	`211`
`212`	`212`	`// Fire on_showing on the route that is now being revealed`
`213`	`213`	`if let Some(last) = self.history.last_mut() {`
`214`	`214`	`if let Ok(route) = &mut last.route {`
`215`		`- route.on_showing(state);`
	`215`	`+ route.on_showing();`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`
`@@ -225,19 +225,15 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`/// Go back with a custom transition`
`228`		`- pub fn back_transition(`
`229`		`- &mut self,`
`230`		`- state: &mut State,`
`231`		`- transition_config: TransitionConfig,`
`232`		`- ) -> RouterResult {`
	`228`	`+ pub fn back_transition(&mut self, transition_config: TransitionConfig) -> RouterResult {`
`233`	`229`	`self.history_kind.back()?;`
`234`		`- self.back_impl(state, transition_config);`
	`230`	`+ self.back_impl(transition_config);`
`235`	`231`	`Ok(())`
`236`	`232`	`}`
`237`	`233`
`238`	`234`	`/// Go back with the default transition`
`239`		`- pub fn back(&mut self, state: &mut State) -> RouterResult {`
`240`		`- self.back_transition(state, self.backward_transition.clone())`
	`235`	`+ pub fn back(&mut self) -> RouterResult {`
	`236`	`+ self.back_transition(self.backward_transition.clone())`
`241`	`237`	`}`
`242`	`238`
`243`	`239`	`/// Replace the current route with a custom transition`
`@@ -266,7 +262,7 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {`
`266`	`262`	`// Fire on_hiding on the leaving route`
`267`	`263`	`if let Some(ref mut leaving) = leaving_route {`
`268`	`264`	`if let Ok(route) = &mut leaving.route {`
`269`		`- route.on_hiding(state);`
	`265`	`+ route.on_hiding();`
`270`	`266`	`}`
`271`	`267`	`}`
`272`	`268`
`@@ -285,7 +281,7 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {`
`285`	`281`	`// Fire on_showing on the newly created route`
`286`	`282`	`if let Some(last) = self.history.last_mut() {`
`287`	`283`	`if let Ok(route) = &mut last.route {`
`288`		`- route.on_showing(state);`
	`284`	`+ route.on_showing();`
`289`	`285`	`}`
`290`	`286`	`}`
`291`	`287`
`@@ -349,7 +345,7 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {`
`349`	`345`	`.retain(\|r\| r.state <= route_state \|\| r.state == active_state);`
`350`	`346`
`351`	`347`	`if route_state < active_state {`
`352`		`- self.back_impl(state, self.backward_transition.clone());`
	`348`	`+ self.back_impl(self.backward_transition.clone());`
`353`	`349`	`}`
`354`	`350`	`} else {`
`355`	`351`	`self.navigate_impl(state, &path, self.forward_transition.clone(), state_index)`
`@@ -402,33 +398,33 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {`
`402`	`398`	`// Leaving route is fully hidden`
`403`	`399`	`if let Some(ref mut leaving) = transition.leaving_route {`
`404`	`400`	`if let Ok(route) = &mut leaving.route {`
`405`		`- route.on_hide(state);`
	`401`	`+ route.on_hide();`
`406`	`402`	`}`
`407`	`403`	`}`
`408`	`404`	`// Current top is fully shown again`
`409`	`405`	`if let Some(last) = self.history.last_mut() {`
`410`	`406`	`if let Ok(route) = &mut last.route {`
`411`		`- route.on_shown(state);`
	`407`	`+ route.on_shown();`
`412`	`408`	`}`
`413`	`409`	`}`
`414`	`410`	`} else {`
`415`	`411`	`// Forward/replace completed`
`416`	`412`	`if let Some(ref mut leaving) = transition.leaving_route {`
`417`	`413`	`// Replace: leaving route is fully hidden`
`418`	`414`	`if let Ok(route) = &mut leaving.route {`
`419`		`- route.on_hide(state);`
	`415`	`+ route.on_hide();`
`420`	`416`	`}`
`421`	`417`	`} else if self.history.len() >= 2 {`
`422`	`418`	`// Forward: previous top is now fully hidden`
`423`	`419`	`let idx = self.history.len() - 2;`
`424`	`420`	`if let Ok(route) = &mut self.history[idx].route {`
`425`		`- route.on_hide(state);`
	`421`	`+ route.on_hide();`
`426`	`422`	`}`
`427`	`423`	`}`
`428`	`424`	`// The new top route is now fully shown`
`429`	`425`	`if let Some(last) = self.history.last_mut() {`
`430`	`426`	`if let Ok(route) = &mut last.route {`
`431`		`- route.on_shown(state);`
	`427`	`+ route.on_shown();`
`432`	`428`	`}`
`433`	`429`	`}`
`434`	`430`	`}`
`@@ -561,14 +557,14 @@ impl<State: 'static, H: History + Default> EguiRouter<State, H> {`
`561`	`557`	`// Fire on_hiding on the popped route`
`562`	`558`	`if let Some(ref mut leaving) = popped {`
`563`	`559`	`if let Ok(route) = &mut leaving.route {`
`564`		`- route.on_hiding(state);`
	`560`	`+ route.on_hiding();`
`565`	`561`	`}`
`566`	`562`	`}`
`567`	`563`
`568`	`564`	`// Fire on_showing on the route being revealed`
`569`	`565`	`if let Some(last) = self.history.last_mut() {`
`570`	`566`	`if let Ok(route) = &mut last.route {`
`571`		`- route.on_showing(state);`
	`567`	`+ route.on_showing();`
`572`	`568`	`}`
`573`	`569`	`}`
`574`	`570`