Skip to content

Commit c6b9c38

Browse files
refactor(web): shared intersection and document-activity stores (#25020)
Co-authored-by: Claude Opus 5.5 <[email protected]>
1 parent b457b64 commit c6b9c38

9 files changed

Lines changed: 496 additions & 79 deletions

‎apps/web/src/components/Sidebar.logic.ts‎

Lines changed: 11 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,7 @@ import {
3030
import type { SidebarThreadSummary, Thread } from "../types";
3131
import { normalizeSearchText } from "../lib/utils";
3232
import { isLatestRunSettled } from "../session-logic";
33+
import { observeIntersection } from "../lib/observeIntersection";
3334

3435
export function shouldNavigateAfterThreadPark(input: {
3536
readonly threadKey: string;
@@ -68,31 +69,23 @@ const SIDEBAR_ROW_SUBSCRIPTION_OVERSCAN_PX = 160;
6869

6970
export function useSidebarRowSubscriptionLease(isActive: boolean): {
7071
readonly leaseLiveStatus: boolean;
71-
readonly rowRef: React.Dispatch<React.SetStateAction<HTMLElement | null>>;
72+
readonly rowRef: (row: HTMLElement | null) => (() => void) | undefined;
7273
} {
73-
const [row, setRow] = React.useState<HTMLElement | null>(null);
7474
const [isNearViewport, setIsNearViewport] = React.useState(isActive);
7575
if (isActive && !isNearViewport) setIsNearViewport(true);
7676
const canObserve = typeof IntersectionObserver !== "undefined";
7777

78-
React.useEffect(() => {
79-
if (isActive || row === null || !canObserve) return;
80-
81-
const scrollRoot = row.closest<HTMLElement>('[data-slot="scroll-area-viewport"]');
82-
const observer = new IntersectionObserver(
83-
([entry]) => setIsNearViewport(entry?.isIntersecting === true),
84-
{
85-
root: scrollRoot,
86-
rootMargin: `${SIDEBAR_ROW_SUBSCRIPTION_OVERSCAN_PX}px 0px`,
87-
},
88-
);
89-
observer.observe(row);
90-
return () => observer.disconnect();
91-
}, [canObserve, isActive, row]);
92-
9378
return {
9479
leaseLiveStatus: isActive || isNearViewport || !canObserve,
95-
rowRef: setRow,
80+
rowRef: (row) => {
81+
if (row === null || isActive || !canObserve) return undefined;
82+
// The overscan has to apply to the sidebar's own scroller; a viewport-rooted
83+
// margin is still clipped by it.
84+
return observeIntersection(row, (entry) => setIsNearViewport(entry.isIntersecting), {
85+
root: row.closest('[data-slot="scroll-area-viewport"]'),
86+
rootMargin: `${SIDEBAR_ROW_SUBSCRIPTION_OVERSCAN_PX}px 0px`,
87+
});
88+
},
9689
};
9790
}
9891

‎apps/web/src/components/diffs/DiffFileLoadingBoundary.tsx‎

Lines changed: 15 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,22 @@
1-
import { useEffect, useRef } from "react";
1+
import { observeIntersection } from "~/lib/observeIntersection";
22
import { DiffFileHeaderSkeleton } from "../DiffPanelShell";
33

44
export function DiffFileLoadingBoundary({ load, count }: { load: () => void; count: number }) {
5-
const ref = useRef<HTMLDivElement>(null);
6-
useEffect(() => {
7-
if (!ref.current) return;
8-
const observer = new IntersectionObserver(
9-
(entries) => {
10-
if (entries.some((entry) => entry.isIntersecting)) load();
11-
},
12-
{ rootMargin: "600px" },
13-
);
14-
observer.observe(ref.current);
15-
return () => observer.disconnect();
16-
}, [load]);
175
return (
18-
<div ref={ref} role="status" aria-label="Loading diff…">
6+
<div
7+
ref={(node) => {
8+
if (!node) return;
9+
return observeIntersection(
10+
node,
11+
(entry) => {
12+
if (entry.isIntersecting) load();
13+
},
14+
{ rootMargin: "600px" },
15+
);
16+
}}
17+
role="status"
18+
aria-label="Loading diff…"
19+
>
1920
{Array.from({ length: Math.min(count, 4) }, (_, index) => (
2021
<div key={index} aria-hidden className="border-b border-border/40">
2122
<DiffFileHeaderSkeleton titleWidth="medium" />
Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
import { describe, expect, it, vi } from "vite-plus/test";
2+
3+
import { render } from "../../../test/render";
4+
import { usePermissionStatus } from "./usePermissionStatus";
5+
6+
function PermissionProbe({
7+
check,
8+
label,
9+
}: {
10+
readonly check: () => Promise<{ screen: boolean }>;
11+
readonly label: string;
12+
}) {
13+
const { status } = usePermissionStatus(async () => check(), { screen: false });
14+
return (
15+
<p>
16+
{label}: {status.screen ? "granted" : "missing"}
17+
</p>
18+
);
19+
}
20+
21+
describe("usePermissionStatus", () => {
22+
it("does not start a new check when the component re-renders", async () => {
23+
// A check that never settles keeps the interval from adding calls, so any
24+
// extra call can only come from the subscription restarting.
25+
const check = vi.fn(() => new Promise<{ screen: boolean }>(() => {}));
26+
await using screen = await render(<PermissionProbe check={check} label="first" />, {
27+
router: false, // the hook does not touch routing
28+
});
29+
await screen.rerender(<PermissionProbe check={check} label="second" />);
30+
await screen.rerender(<PermissionProbe check={check} label="third" />);
31+
32+
await expect.element(screen.getByText("third: missing")).toBeInTheDocument();
33+
expect(check).toHaveBeenCalledTimes(1);
34+
});
35+
});
Lines changed: 89 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,89 @@
1+
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
2+
3+
import { createPermissionPoller } from "./usePermissionStatus";
4+
5+
function deferred<T>() {
6+
let resolve!: (value: T) => void;
7+
let reject!: (error: unknown) => void;
8+
const promise = new Promise<T>((res, rej) => {
9+
resolve = res;
10+
reject = rej;
11+
});
12+
return { promise, resolve, reject };
13+
}
14+
15+
describe("createPermissionPoller", () => {
16+
beforeEach(() => {
17+
vi.useFakeTimers();
18+
});
19+
afterEach(() => {
20+
vi.useRealTimers();
21+
});
22+
23+
it("checks on subscribe and on every interval, publishing each result", async () => {
24+
const onChange = vi.fn();
25+
let granted = false;
26+
const check = vi.fn(async () => ({ screen: granted }));
27+
const poller = createPermissionPoller(check, { screen: false });
28+
const stop = poller.subscribe(onChange);
29+
30+
await vi.advanceTimersByTimeAsync(0);
31+
expect(check).toHaveBeenCalledTimes(1);
32+
granted = true;
33+
await vi.advanceTimersByTimeAsync(1500);
34+
expect(check).toHaveBeenCalledTimes(2);
35+
expect(poller.getSnapshot()).toEqual({ status: { screen: true }, error: null });
36+
expect(onChange).toHaveBeenCalledTimes(2);
37+
38+
stop();
39+
await vi.advanceTimersByTimeAsync(3000);
40+
expect(check).toHaveBeenCalledTimes(2);
41+
});
42+
43+
it("never overlaps checks while one is still pending", async () => {
44+
const pending = deferred<{ screen: boolean }>();
45+
const check = vi.fn(() => pending.promise);
46+
const poller = createPermissionPoller(check, { screen: false });
47+
const stop = poller.subscribe(() => {});
48+
49+
await vi.advanceTimersByTimeAsync(4500);
50+
expect(check).toHaveBeenCalledTimes(1);
51+
pending.resolve({ screen: true });
52+
await vi.advanceTimersByTimeAsync(1500);
53+
expect(check).toHaveBeenCalledTimes(2);
54+
stop();
55+
});
56+
57+
it("keeps the last status on failure and clears the error on the next success", async () => {
58+
let fail = false;
59+
const check = vi.fn(async () => {
60+
if (fail) throw new Error("unavailable");
61+
return { screen: true };
62+
});
63+
const poller = createPermissionPoller(check, { screen: false });
64+
const stop = poller.subscribe(() => {});
65+
66+
await vi.advanceTimersByTimeAsync(0);
67+
fail = true;
68+
await vi.advanceTimersByTimeAsync(1500);
69+
expect(poller.getSnapshot().status).toEqual({ screen: true });
70+
expect(poller.getSnapshot().error).not.toBeNull();
71+
fail = false;
72+
await vi.advanceTimersByTimeAsync(1500);
73+
expect(poller.getSnapshot().error).toBeNull();
74+
stop();
75+
});
76+
77+
it("drops a result that lands after unsubscribing", async () => {
78+
const pending = deferred<{ screen: boolean }>();
79+
const onChange = vi.fn();
80+
const poller = createPermissionPoller(() => pending.promise, { screen: false });
81+
const stop = poller.subscribe(onChange);
82+
83+
stop();
84+
pending.resolve({ screen: true });
85+
await vi.advanceTimersByTimeAsync(0);
86+
expect(onChange).not.toHaveBeenCalled();
87+
expect(poller.getSnapshot().status).toEqual({ screen: false });
88+
});
89+
});

‎apps/web/src/components/permissions/usePermissionStatus.ts‎

Lines changed: 71 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -1,42 +1,80 @@
1-
import { useEffect, useEffectEvent, useState } from "react";
1+
import { useState, useSyncExternalStore } from "react";
22

3+
import { getDocumentActivity, subscribeDocumentActivity } from "~/lib/documentActivity";
4+
5+
const POLL_INTERVAL_MS = 1500;
6+
const CHECK_FAILED_MESSAGE = "Could not check permissions. We'll try again automatically.";
7+
8+
interface PermissionSnapshot<Id extends string> {
9+
readonly status: Record<Id, boolean>;
10+
readonly error: string | null;
11+
}
12+
13+
/**
14+
* Holds the last permission check result and polls while subscribed: on
15+
* subscribe, every interval, and when the window regains focus or visibility.
16+
* Checks are skipped while the tab is hidden and never overlap.
17+
*/
18+
export function createPermissionPoller<Id extends string>(
19+
check: () => Promise<Record<Id, boolean>>,
20+
initialStatus: Record<Id, boolean>,
21+
) {
22+
let snapshot: PermissionSnapshot<Id> = { status: initialStatus, error: null };
23+
return {
24+
getSnapshot: () => snapshot,
25+
subscribe(onChange: () => void): () => void {
26+
let disposed = false;
27+
let checking = false;
28+
const publish = (next: PermissionSnapshot<Id>) => {
29+
if (disposed) return;
30+
snapshot = next;
31+
onChange();
32+
};
33+
const refresh = async () => {
34+
if (disposed || checking || !getDocumentActivity().visible) return;
35+
checking = true;
36+
try {
37+
publish({ status: await check(), error: null });
38+
} catch {
39+
publish({ status: snapshot.status, error: CHECK_FAILED_MESSAGE });
40+
}
41+
checking = false;
42+
};
43+
void refresh();
44+
const timer = setInterval(() => void refresh(), POLL_INTERVAL_MS);
45+
let previous = getDocumentActivity();
46+
const stopActivity = subscribeDocumentActivity(() => {
47+
const next = getDocumentActivity();
48+
const regained = (next.focused && !previous.focused) || next.visible !== previous.visible;
49+
previous = next;
50+
if (regained) void refresh();
51+
});
52+
return () => {
53+
disposed = true;
54+
clearInterval(timer);
55+
stopActivity();
56+
};
57+
},
58+
};
59+
}
60+
61+
const noopSubscribe = () => () => {};
62+
63+
/**
64+
* `check` and `initialStatus` are read once, when the component mounts, so the
65+
* subscription only restarts when `enabled` flips. Key the component if what it
66+
* checks can change.
67+
*/
368
export function usePermissionStatus<Id extends string>(
469
check: () => Promise<Record<Id, boolean>>,
570
initialStatus: Record<Id, boolean>,
671
enabled = true,
772
) {
8-
const [status, setStatus] = useState(initialStatus);
9-
const [error, setError] = useState<string | null>(null);
10-
const checkLatest = useEffectEvent(check);
11-
useEffect(() => {
12-
if (!enabled) return;
13-
let disposed = false;
14-
let checking = false;
15-
const refresh = async () => {
16-
if (disposed || checking || document.visibilityState === "hidden") return;
17-
checking = true;
18-
try {
19-
const next = await checkLatest();
20-
if (!disposed) {
21-
setStatus(next);
22-
setError(null);
23-
}
24-
} catch {
25-
if (!disposed) setError("Could not check permissions. We'll try again automatically.");
26-
}
27-
checking = false;
28-
};
29-
void refresh();
30-
const timer = window.setInterval(() => void refresh(), 1500);
31-
window.addEventListener("focus", refresh);
32-
document.addEventListener("visibilitychange", refresh);
33-
return () => {
34-
disposed = true;
35-
window.clearInterval(timer);
36-
window.removeEventListener("focus", refresh);
37-
document.removeEventListener("visibilitychange", refresh);
38-
};
39-
}, [enabled]);
73+
const [poller] = useState(() => createPermissionPoller(check, initialStatus));
74+
const { status, error } = useSyncExternalStore(
75+
enabled ? poller.subscribe : noopSubscribe,
76+
poller.getSnapshot,
77+
);
4078
return {
4179
status,
4280
error,

‎apps/web/src/components/settings/ProjectFaviconThumbnail.tsx‎

Lines changed: 16 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,30 +1,19 @@
11
import type { EnvironmentId } from "@t3tools/contracts";
2-
import { type ReactNode, useEffect, useRef, useState } from "react";
2+
import { type ReactNode, useState } from "react";
33

44
import { useAssetUrlState } from "~/assets/assetUrls";
5+
import { observeIntersection } from "~/lib/observeIntersection";
56

67
export function ProjectFaviconThumbnail(props: {
78
readonly cwd: string;
89
readonly environmentId: EnvironmentId;
910
readonly fallback: ReactNode;
1011
readonly path: string;
1112
}) {
12-
const ref = useRef<HTMLSpanElement>(null);
1313
const [inView, setInView] = useState(() => typeof IntersectionObserver === "undefined");
1414
const [loadedUrl, setLoadedUrl] = useState<string | null>(null);
1515
const [failedUrl, setFailedUrl] = useState<string | null>(null);
1616

17-
// Asset URLs require a server request, so defer acquisition until the row is visible.
18-
useEffect(() => {
19-
const element = ref.current;
20-
if (inView || !element) return;
21-
const observer = new IntersectionObserver((entries) => {
22-
if (entries.some((entry) => entry.isIntersecting)) setInView(true);
23-
});
24-
observer.observe(element);
25-
return () => observer.disconnect();
26-
}, [inView]);
27-
2817
const state = useAssetUrlState(
2918
props.environmentId,
3019
inView ? { _tag: "draft-workspace-file", cwd: props.cwd, path: props.path } : null,
@@ -35,7 +24,20 @@ export function ProjectFaviconThumbnail(props: {
3524
const imageLoaded = showImage && loadedUrl === url;
3625

3726
return (
38-
<span ref={ref} className="relative flex size-8 shrink-0 items-center justify-center">
27+
<span
28+
// Asset URLs require a server request, so defer acquisition until the row is visible.
29+
ref={
30+
inView
31+
? undefined
32+
: (node) => {
33+
if (!node) return;
34+
return observeIntersection(node, (entry) => {
35+
if (entry.isIntersecting) setInView(true);
36+
});
37+
}
38+
}
39+
className="relative flex size-8 shrink-0 items-center justify-center"
40+
>
3941
{!imageLoaded ? props.fallback : null}
4042
{showImage ? (
4143
<img

0 commit comments

Comments
 (0)