fix: correctly update path stack when navigating backwards (closes #4324)

examples/regression/e2e/features/issue_4251.feature

@@ -0,0 +1,13 @@
+@check_issue_4251
+Feature: Check that issue 4251 does not reappear
+
+	Scenario: Clicking a link to the same page you’re currently on should not add the page to the history stack.
+		Given I see the app
+		And I can access regression test 4324
+		When I select the link This page
+		And I select the link This page
+		And I select the link This page
+		Then I see the result is the string Issue4324
+		When I press the back button
+		And I select the link 4324
+		Then I see the result is the string Issue4324

examples/regression/e2e/features/issue_4324.feature

@@ -0,0 +1,11 @@
+@check_issue_4324
+Feature: Check that issue 4324 does not reappear
+
+	Scenario: Navigating to the same page after clicking "Back" should set the URL correctly
+		Given I see the app
+		And I can access regression test 4324
+		Then I see the path is /4324/
+		When I press the back button
+		Then I see the path is /
+		When I select the link 4324
+		Then I see the path is /4324/

examples/regression/e2e/tests/fixtures/check.rs

@@ -43,3 +43,13 @@ pub async fn element_value_is(
     assert_eq!(value.as_deref(), Some(expected));
     Ok(())
 }
+
+pub async fn path_is(client: &Client, expected_path: &str) -> Result<()> {
+    let url = client
+        .current_url()
+        .await
+        .expect("could not access current URL");
+    let path = url.path();
+    assert_eq!(expected_path, path);
+    Ok(())
+}

examples/regression/e2e/tests/fixtures/world/action_steps.rs

@@ -45,3 +45,12 @@ async fn i_refresh_the_browser(world: &mut AppWorld) -> Result<()> {
 
     Ok(())
 }
+
+#[given(regex = "^I press the back button$")]
+#[when(regex = "^I press the back button$")]
+async fn i_go_back(world: &mut AppWorld) -> Result<()> {
+    let client = &world.client;
+    client.back().await?;
+
+    Ok(())
+}

examples/regression/e2e/tests/fixtures/world/check_steps.rs

@@ -43,3 +43,10 @@ async fn i_see_the_value(
     check::element_value_is(client, &id, &value).await?;
     Ok(())
 }
+
+#[then(regex = r"^I see the path is (.*)$")]
+async fn i_see_the_path(world: &mut AppWorld, path: String) -> Result<()> {
+    let client = &world.client;
+    check::path_is(client, &path).await?;
+    Ok(())
+}

examples/regression/src/app.rs

@@ -1,7 +1,7 @@
 use crate::{
     issue_4005::Routes4005, issue_4088::Routes4088, issue_4217::Routes4217,
-    issue_4285::Routes4285, issue_4296::Routes4296, pr_4015::Routes4015,
-    pr_4091::Routes4091,
+    issue_4285::Routes4285, issue_4296::Routes4296, issue_4324::Routes4324,
+    pr_4015::Routes4015, pr_4091::Routes4091,
 };
 use leptos::prelude::*;
 use leptos_meta::{MetaTags, *};
@@ -47,6 +47,7 @@ pub fn App() -> impl IntoView {
                     <Routes4005/>
                     <Routes4285/>
                     <Routes4296/>
+                    <Routes4324/>
                 </Routes>
             </main>
         </Router>
@@ -73,6 +74,7 @@ fn HomePage() -> impl IntoView {
                 <li><a href="/4005/">"4005"</a></li>
                 <li><a href="/4285/">"4285"</a></li>
                 <li><a href="/4296/">"4296"</a></li>
+                <li><a href="/4324/">"4324"</a></li>
             </ul>
         </nav>
     }

examples/regression/src/issue_4324.rs

@@ -0,0 +1,21 @@
+use leptos::prelude::*;
+#[allow(unused_imports)]
+use leptos_router::{
+    components::Route, path, Lazy, MatchNestedRoutes, NavigateOptions,
+};
+
+#[component]
+pub fn Routes4324() -> impl MatchNestedRoutes + Clone {
+    view! {
+        <Route path=path!("4324") view=Issue4324/>
+    }
+    .into_inner()
+}
+
+#[component]
+pub fn Issue4324() -> impl IntoView {
+    view! {
+        <a href="/4324/">"This page"</a>
+        <p id="result">"Issue4324"</p>
+    }
+}

examples/regression/src/lib.rs

@@ -4,6 +4,7 @@ mod issue_4088;
 mod issue_4217;
 mod issue_4285;
 mod issue_4296;
+mod issue_4324;
 mod pr_4015;
 mod pr_4091;
 

router/src/location/history.rs

@@ -185,11 +185,15 @@ impl LocationProvider for BrowserUrl {
             let is_back = self.is_back.clone();
             move || match Self::current() {
                 Ok(new_url) => {
-                    let stack = path_stack.read_value();
+                    let mut stack = path_stack.write_value();
                     let is_navigating_back = stack.len() == 1
                         || (stack.len() >= 2
                             && stack.get(stack.len() - 2) == Some(&new_url));
 
+                    if is_navigating_back {
+                        stack.pop();
+                    }
+
                     is_back.set(is_navigating_back);
 
                     url.set(new_url);

tachys/src/ssr/mod.rs

@@ -378,91 +378,83 @@ impl Stream for StreamBuilder {
             let next_chunk = this.chunks.pop_front();
             match next_chunk {
                 None => {
-                    if this.pending_ooo.is_empty() {
-                        if this.sync_buf.is_empty() {
-                            Poll::Ready(None)
-                        } else {
-                            Poll::Ready(Some(mem::take(&mut this.sync_buf)))
-                        }
-                    } else {
-                        // check if *any* pending out-of-order chunk is ready
-                        for mut chunk in mem::take(&mut this.pending_ooo) {
-                            match chunk.as_mut().poll(cx) {
-                                Poll::Ready(OooChunk {
-                                    id,
-                                    chunks,
-                                    replace,
-                                    nonce,
-                                }) => {
-                                    let opening = format!("<!--s-{id}o-->");
-                                    let placeholder_at =
-                                        this.sync_buf.find(&opening);
-                                    if let Some(start) = placeholder_at {
-                                        let closing = format!("<!--s-{id}c-->");
-                                        let end = this
-                                            .sync_buf
-                                            .find(&closing)
-                                            .unwrap();
-                                        let chunks_iter =
-                                            chunks.into_iter().rev();
+                    // now, handle out-of-order chunks
+                    if let Some(mut pending) = this.pending_ooo.pop_front() {
+                        match pending.as_mut().poll(cx) {
+                            Poll::Ready(OooChunk {
+                                id,
+                                chunks,
+                                replace,
+                                nonce,
+                            }) => {
+                                let opening = format!("<!--s-{id}o-->");
+                                let placeholder_at =
+                                    this.sync_buf.find(&opening);
+                                if let Some(start) = placeholder_at {
+                                    let closing = format!("<!--s-{id}c-->");
+                                    let end =
+                                        this.sync_buf.find(&closing).unwrap();
+                                    let chunks_iter = chunks.into_iter().rev();
 
-                                        // TODO can probably make this more efficient
-                                        let (before, replaced) =
-                                            this.sync_buf.split_at(start);
-                                        let (_, after) = replaced.split_at(
-                                            end - start + closing.len(),
-                                        );
-                                        let mut buf = String::new();
-                                        buf.push_str(before);
+                                    // TODO can probably make this more efficient
+                                    let (before, replaced) =
+                                        this.sync_buf.split_at(start);
+                                    let (_, after) = replaced
+                                        .split_at(end - start + closing.len());
+                                    let mut buf = String::new();
+                                    buf.push_str(before);
 
-                                        let mut held_chunks = VecDeque::new();
-                                        for chunk in chunks_iter {
-                                            if let StreamChunk::Sync(ready) =
-                                                chunk
-                                            {
-                                                buf.push_str(&ready);
-                                            } else {
-                                                held_chunks.push_front(chunk);
-                                            }
+                                    let mut held_chunks = VecDeque::new();
+                                    for chunk in chunks_iter {
+                                        if let StreamChunk::Sync(ready) = chunk
+                                        {
+                                            buf.push_str(&ready);
+                                        } else {
+                                            held_chunks.push_front(chunk);
                                         }
-                                        buf.push_str(after);
-                                        this.sync_buf = buf;
-                                        for chunk in held_chunks {
+                                    }
+                                    buf.push_str(after);
+                                    this.sync_buf = buf;
+                                    for chunk in held_chunks {
+                                        this.chunks.push_front(chunk);
+                                    }
+                                } else {
+                                    OooChunk::push_start(
+                                        &id,
+                                        &mut this.sync_buf,
+                                    );
+                                    for chunk in chunks.into_iter().rev() {
+                                        if let StreamChunk::Sync(ready) = chunk
+                                        {
+                                            this.sync_buf.push_str(&ready);
+                                        } else {
                                             this.chunks.push_front(chunk);
                                         }
-                                    } else {
-                                        OooChunk::push_start(
-                                            &id,
-                                            &mut this.sync_buf,
-                                        );
-                                        for chunk in chunks.into_iter().rev() {
-                                            if let StreamChunk::Sync(ready) =
-                                                chunk
-                                            {
-                                                this.sync_buf.push_str(&ready);
-                                            } else {
-                                                this.chunks.push_front(chunk);
-                                            }
-                                        }
-                                        OooChunk::push_end_with_nonce(
-                                            replace,
-                                            &id,
-                                            &mut this.sync_buf,
-                                            nonce.as_deref(),
-                                        );
                                     }
+                                    OooChunk::push_end_with_nonce(
+                                        replace,
+                                        &id,
+                                        &mut this.sync_buf,
+                                        nonce.as_deref(),
+                                    );
                                 }
-                                Poll::Pending => {
-                                    this.pending_ooo.push_back(chunk);
+                                self.poll_next(cx)
+                            }
+                            Poll::Pending => {
+                                this.pending_ooo.push_back(pending);
+                                if this.sync_buf.is_empty() {
+                                    Poll::Pending
+                                } else {
+                                    Poll::Ready(Some(mem::take(
+                                        &mut this.sync_buf,
+                                    )))
                                 }
                             }
                         }
-
-                        if this.sync_buf.is_empty() {
-                            Poll::Pending
-                        } else {
-                            Poll::Ready(Some(mem::take(&mut this.sync_buf)))
-                        }
+                    } else if this.sync_buf.is_empty() {
+                        Poll::Ready(None)
+                    } else {
+                        Poll::Ready(Some(mem::take(&mut this.sync_buf)))
                     }
                 }
                 Some(StreamChunk::Sync(value)) => {