Skip to content

The open-source app everyone uses to manage agents at work

fix(ui): restore main-content scroll position on browser back/forward (#8636)

Devin Foleyfdb8b5678be9
diff --git a/ui/src/components/Layout.tsx b/ui/src/components/Layout.tsx
index 44af0a81d8..8619a3247a 100644
--- a/ui/src/components/Layout.tsx
+++ b/ui/src/components/Layout.tsx
@@ -32,6 +32,8 @@ import { healthApi } from "../api/health";
import { instanceSettingsApi } from "../api/instanceSettings";
import { shouldSyncCompanySelectionFromRoute } from "../lib/company-selection";
import {
+ applyMainContentScrollTop,
+ NavigationScrollMemory,
resetNavigationScroll,
shouldResetScrollOnNavigation,
} from "../lib/navigation-scroll";
@@ -87,6 +89,8 @@ export function Layout() {
const lastMainScrollTop = useRef(0);
const previousPathname = useRef<string | null>(null);
const mainContentRef = useRef<HTMLElement | null>(null);
+ const scrollMemory = useRef(new NavigationScrollMemory());
+ const activeScrollKey = useRef<string>(location.key);
const [mobileNavVisible, setMobileNavVisible] = useState(true);
const [shortcutsOpen, setShortcutsOpen] = useState(false);
const matchedCompany = useMemo(() => {
@@ -450,7 +454,20 @@ export function Layout() {
return scheduleMainContentFocus(mainContent);
}, [location.pathname]);
+ // Continuously record the scroll offset of the active history entry so a
+ // later back/forward navigation can restore it (see NavigationScrollMemory).
useEffect(() => {
+ const main = mainContentRef.current;
+ if (!main) return;
+ const recordScroll = () => {
+ scrollMemory.current.remember(activeScrollKey.current, main.scrollTop);
+ };
+ main.addEventListener("scroll", recordScroll, { passive: true });
+ return () => main.removeEventListener("scroll", recordScroll);
+ }, []);
+
+ useLayoutEffect(() => {
+ const main = mainContentRef.current;
const shouldResetScroll = shouldResetScrollOnNavigation({
previousPathname: previousPathname.current,
pathname: location.pathname,
@@ -460,9 +477,22 @@ export function Layout() {
previousPathname.current = location.pathname;
- if (!shouldResetScroll) return;
- resetNavigationScroll(mainContentRef.current);
- }, [location.pathname, navigationType]);
+ const isHistoryPop = navigationType === "POP";
+ const restoredScrollTop = isHistoryPop ? scrollMemory.current.recall(location.key) : 0;
+ activeScrollKey.current = location.key;
+
+ if (isHistoryPop) {
+ applyMainContentScrollTop(main, restoredScrollTop);
+ // Cached page content can finish laying out a frame after commit; re-apply
+ // once it has so the restored offset isn't clamped to a shorter interim height.
+ const raf = requestAnimationFrame(() => applyMainContentScrollTop(main, restoredScrollTop));
+ return () => cancelAnimationFrame(raf);
+ }
+
+ if (shouldResetScroll) {
+ resetNavigationScroll(main);
+ }
+ }, [location.key, location.pathname, location.state, navigationType]);
return (
<GeneralSettingsProvider value={{ keyboardShortcutsEnabled }}>
diff --git a/ui/src/lib/navigation-scroll.test.ts b/ui/src/lib/navigation-scroll.test.ts
index 967dfa19f3..8bd40f9ae2 100644
--- a/ui/src/lib/navigation-scroll.test.ts
+++ b/ui/src/lib/navigation-scroll.test.ts
@@ -2,6 +2,8 @@
import { describe, expect, it, vi } from "vitest";
import {
+ applyMainContentScrollTop,
+ NavigationScrollMemory,
resetNavigationScroll,
SIDEBAR_SCROLL_RESET_STATE,
shouldResetScrollOnNavigation,
@@ -123,4 +125,33 @@ describe("navigation-scroll", () => {
expect(document.body.scrollLeft).toBe(0);
expect(windowScrollTo).toHaveBeenCalledWith({ top: 0, left: 0, behavior: "auto" });
});
+
+ it("remembers and recalls scroll offsets per history key", () => {
+ const memory = new NavigationScrollMemory();
+ expect(memory.recall("missing")).toBe(0);
+
+ memory.remember("inbox", 640);
+ memory.remember("issue", 1820);
+ expect(memory.recall("inbox")).toBe(640);
+ expect(memory.recall("issue")).toBe(1820);
+
+ memory.remember("inbox", 700);
+ expect(memory.recall("inbox")).toBe(700);
+
+ memory.remember("inbox", -50);
+ expect(memory.recall("inbox")).toBe(0);
+ });
+
+ it("restores a remembered scroll offset onto the main content element", () => {
+ const main = document.createElement("main");
+ main.scrollTo = vi.fn();
+
+ applyMainContentScrollTop(main, 540);
+
+ expect(main.scrollTo).toHaveBeenCalledWith({ top: 540, left: 0, behavior: "auto" });
+ expect(main.scrollTop).toBe(540);
+ expect(main.scrollLeft).toBe(0);
+
+ expect(() => applyMainContentScrollTop(null, 540)).not.toThrow();
+ });
});
diff --git a/ui/src/lib/navigation-scroll.ts b/ui/src/lib/navigation-scroll.ts
index 6ea8a1bb80..bbe2b61c57 100644
--- a/ui/src/lib/navigation-scroll.ts
+++ b/ui/src/lib/navigation-scroll.ts
@@ -18,6 +18,30 @@ export function shouldResetScrollOnNavigation(params: {
return hasSidebarScrollResetState(state);
}
+// Remembers the `#main-content` scroll offset per browser-history entry so a
+// back/forward (POP) navigation can be restored to where the user left off.
+// `#main-content` is a single element that survives route changes, so without
+// this the offset from the page we navigated away from (e.g. a deep
+// issue-detail scroll) bleeds into the page we return to (e.g. the inbox).
+export class NavigationScrollMemory {
+ private positions = new Map<string, number>();
+
+ remember(key: string, scrollTop: number): void {
+ this.positions.set(key, Math.max(0, scrollTop));
+ }
+
+ recall(key: string): number {
+ return this.positions.get(key) ?? 0;
+ }
+}
+
+export function applyMainContentScrollTop(mainElement: HTMLElement | null, scrollTop: number): void {
+ if (!mainElement) return;
+ mainElement.scrollTo?.({ top: scrollTop, left: 0, behavior: "auto" });
+ mainElement.scrollTop = scrollTop;
+ mainElement.scrollLeft = 0;
+}
+
export function resetNavigationScroll(mainElement: HTMLElement | null): void {
mainElement?.scrollTo?.({ top: 0, left: 0, behavior: "auto" });