Skip to content

A desktop coding agent with free access to frontier models.

TypeScript

fix: keep window state for later cards

ogsamratca0ba0ab2bce
diff --git a/apps/app/src/app/lib/placement-viewability.ts b/apps/app/src/app/lib/placement-viewability.ts
index 7dd189b1..0ce2f9a4 100644
--- a/apps/app/src/app/lib/placement-viewability.ts
+++ b/apps/app/src/app/lib/placement-viewability.ts
@@ -107,19 +107,79 @@ function defaultEnv(): ViewabilityEnv | null {
return { win: window, doc: document, IntersectionObserver: (globalThis as { IntersectionObserver?: ObserverCtor }).IntersectionObserver ?? null };
}
+type WindowState = {
+ /** The last focus / blur the window reported (null: none yet; document.hasFocus() decides). */
+ focused: boolean | null;
+ minimized: boolean;
+ visible: boolean;
+};
+type WindowTracker = { state: WindowState; listen: (fn: () => void) => () => void };
+
+const trackers = new WeakMap<object, WindowTracker>();
+
+/**
+ * The app window's state, followed from the page's start (not from a card's
+ * mount): the main process keeps the page "visible" while the window is
+ * hidden or minimized (no background throttling), so its own report
+ * (WINDOW_STATE_EVENT) and the focus / blur events are remembered here for
+ * every card that mounts later.
+ */
+export function trackPlacementWindow(win: ViewabilityEnv["win"] | null = typeof window === "undefined" ? null : window): WindowTracker | null {
+ if (!win) return null;
+ const known = trackers.get(win);
+ if (known) return known;
+ const state: WindowState = { focused: null, minimized: false, visible: true };
+ const listeners = new Set<() => void>();
+ const changed = () => {
+ for (const fn of listeners) fn();
+ };
+ win.addEventListener("focus", () => {
+ state.focused = true;
+ changed();
+ });
+ win.addEventListener("blur", () => {
+ state.focused = false;
+ changed();
+ });
+ win.addEventListener(WINDOW_STATE_EVENT, (event: Event) => {
+ const detail: unknown = "detail" in event ? event.detail : null;
+ if (!detail || typeof detail !== "object") return;
+ const next = detail as { focused?: unknown; minimized?: unknown; visible?: unknown };
+ if (typeof next.focused === "boolean") state.focused = next.focused;
+ if (typeof next.minimized === "boolean") state.minimized = next.minimized;
+ if (typeof next.visible === "boolean") state.visible = next.visible;
+ changed();
+ });
+ const tracker: WindowTracker = {
+ state,
+ listen(fn) {
+ listeners.add(fn);
+ return () => {
+ listeners.delete(fn);
+ };
+ },
+ };
+ trackers.set(win, tracker);
+ return tracker;
+}
+
/**
* Measures `element` (the card) and calls `onViewable` once when it
* qualifies. Resolves the cleanup.
*/
export function observeViewability(element: Element, onViewable: () => void, env: ViewabilityEnv | null = defaultEnv()): () => void {
if (!env || typeof env.IntersectionObserver !== "function") return () => undefined;
- const { win, doc } = env;
+ const { doc } = env;
+ const tracker = trackPlacementWindow(env.win);
+ if (!tracker) return () => undefined;
const timer = createViewabilityTimer(onViewable, env);
- let minimized = false;
- let hidden = false;
- const focus = () => !minimized && !hidden && doc.hasFocus();
- const pageVisible = () => doc.visibilityState === "visible";
- timer.update({ pageVisible: pageVisible(), windowFocused: focus() });
+ const shown = () => tracker.state.visible && !tracker.state.minimized;
+ // Any signal of "not focused" wins: the window's last report and the document's own focus.
+ const conditions = () => ({
+ pageVisible: doc.visibilityState === "visible" && shown(),
+ windowFocused: shown() && tracker.state.focused !== false && doc.hasFocus(),
+ });
+ timer.update(conditions());
const observer = new env.IntersectionObserver(
(entries) => {
@@ -131,26 +191,14 @@ export function observeViewability(element: Element, onViewable: () => void, env
);
observer.observe(element);
- const onVisibility = () => timer.update({ pageVisible: pageVisible(), windowFocused: focus() });
- const onFocus = () => timer.update({ windowFocused: focus() });
- const onBlur = () => timer.update({ windowFocused: false });
- const onWindowState = (event: Event) => {
- const detail = (event as CustomEvent<{ focused?: boolean; minimized?: boolean; visible?: boolean }>).detail ?? {};
- minimized = detail.minimized === true;
- hidden = detail.visible === false;
- timer.update({ windowFocused: detail.focused === false ? false : focus(), pageVisible: pageVisible() });
- };
- doc.addEventListener("visibilitychange", onVisibility);
- win.addEventListener("focus", onFocus);
- win.addEventListener("blur", onBlur);
- win.addEventListener(WINDOW_STATE_EVENT, onWindowState);
+ const update = () => timer.update(conditions());
+ const unlisten = tracker.listen(update);
+ doc.addEventListener("visibilitychange", update);
return () => {
timer.stop();
observer.disconnect();
- doc.removeEventListener("visibilitychange", onVisibility);
- win.removeEventListener("focus", onFocus);
- win.removeEventListener("blur", onBlur);
- win.removeEventListener(WINDOW_STATE_EVENT, onWindowState);
+ unlisten();
+ doc.removeEventListener("visibilitychange", update);
};
}
diff --git a/apps/app/src/react-app/domains/placements/placements.tsx b/apps/app/src/react-app/domains/placements/placements.tsx
index 599a351e..4b7c8e64 100644
--- a/apps/app/src/react-app/domains/placements/placements.tsx
+++ b/apps/app/src/react-app/domains/placements/placements.tsx
@@ -29,7 +29,10 @@ import {
usePlacementsStore,
type Placement,
} from "../../../app/lib/placements";
-import { observeViewability } from "../../../app/lib/placement-viewability";
+import { observeViewability, trackPlacementWindow } from "../../../app/lib/placement-viewability";
+
+// The window's focus / minimize / show state from the start, before any card mounts.
+trackPlacementWindow();
/** rendered on the first paint, viewable when measured: once per display. */
function useDisplayMeasurement(ref: RefObject<HTMLElement | null>, placement: Placement) {
diff --git a/apps/app/tests/placement-viewability.test.ts b/apps/app/tests/placement-viewability.test.ts
index edc109e0..d71cbd10 100644
--- a/apps/app/tests/placement-viewability.test.ts
+++ b/apps/app/tests/placement-viewability.test.ts
@@ -4,6 +4,7 @@ import {
createViewabilityTimer,
observeViewability,
qualifies,
+ trackPlacementWindow,
VIEWABLE_MS,
VIEWABLE_RATIO,
WINDOW_STATE_EVENT,
@@ -203,6 +204,7 @@ function page({ focused = true, visible = true } = {}) {
};
return {
env: env as never,
+ win: env.win as never,
clock: c,
intersect: (ratio: number) => observerCallback?.([{ isIntersecting: ratio > 0, intersectionRatio: ratio }]),
focus: () => {
@@ -222,7 +224,7 @@ function page({ focused = true, visible = true } = {}) {
for (const fn of docListeners.get("visibilitychange") ?? []) fn();
},
windowState: (detail: { focused: boolean; minimized: boolean; visible: boolean }) => emit(WINDOW_STATE_EVENT, detail),
- listenerCount: () => [...listeners.values()].reduce((n, s) => n + s.size, 0) + [...docListeners.values()].reduce((n, s) => n + s.size, 0),
+ docListenerCount: () => [...docListeners.values()].reduce((n, s) => n + s.size, 0),
disconnected: () => disconnected,
};
}
@@ -321,12 +323,49 @@ describe("viewability: on the page", () => {
stop();
});
- test("cleanup removes every listener and the observer", () => {
+ test("cleanup removes the card's listeners and the observer; nothing fires after", () => {
const p = page();
- const stop = observeViewability(el, () => undefined, p.env);
- expect(p.listenerCount()).toBeGreaterThan(0);
+ let fired = 0;
+ const stop = observeViewability(el, () => fired++, p.env);
+ expect(p.docListenerCount()).toBeGreaterThan(0);
+ p.intersect(1);
+ p.clock.advance(500);
stop();
- expect(p.listenerCount()).toBe(0);
+ expect(p.docListenerCount()).toBe(0);
expect(p.disconnected()).toBe(true);
+ p.blur();
+ p.focus();
+ p.clock.advance(5_000);
+ expect(fired).toBe(0);
+ });
+
+ test("a window hidden or minimized before the card mounted: none until it is shown (the page itself still says visible)", () => {
+ const p = page();
+ trackPlacementWindow(p.win);
+ p.windowState({ focused: false, minimized: false, visible: false });
+ let fired = 0;
+ observeViewability(el, () => fired++, p.env);
+ p.intersect(1);
+ p.clock.advance(5_000);
+ expect(fired).toBe(0);
+ p.windowState({ focused: true, minimized: false, visible: true });
+ p.clock.advance(999);
+ expect(fired).toBe(0);
+ p.clock.advance(1);
+ expect(fired).toBe(1);
+ });
+
+ test("a blur before the card mounted is remembered too", () => {
+ const p = page();
+ trackPlacementWindow(p.win);
+ p.blur();
+ let fired = 0;
+ observeViewability(el, () => fired++, p.env);
+ p.intersect(1);
+ p.clock.advance(5_000);
+ expect(fired).toBe(0);
+ p.focus();
+ p.clock.advance(1_000);
+ expect(fired).toBe(1);
});
});
diff --git a/apps/desktop/electron/placements-desktop.mjs b/apps/desktop/electron/placements-desktop.mjs
index 1d6d41ca..e3bd29a1 100644
--- a/apps/desktop/electron/placements-desktop.mjs
+++ b/apps/desktop/electron/placements-desktop.mjs
@@ -29,8 +29,11 @@ export const WINDOW_STATE_CHANNEL = "omnirush:placements:window";
/**
* Pushes the window's focus / minimize / show state to its page (the
- * viewability timer's "window focused and visible"). Returns the unhook.
- * @param {{ on: Function, removeListener: Function, isFocused: () => boolean, isMinimized: () => boolean, isVisible: () => boolean, isDestroyed: () => boolean, webContents: { send: Function, isDestroyed?: () => boolean } }} win
+ * viewability timer's "window focused and visible"): on every change and
+ * whenever the page (re)loads. The page cannot tell by itself: the window
+ * keeps it "visible" while hidden or minimized (no background throttling).
+ * Returns the unhook.
+ * @param {{ on: Function, removeListener: Function, isFocused: () => boolean, isMinimized: () => boolean, isVisible: () => boolean, isDestroyed: () => boolean, webContents: { send: Function, on: Function, removeListener: Function, isDestroyed?: () => boolean } }} win
*/
export function watchWindowForPlacements(win) {
const events = ["focus", "blur", "minimize", "restore", "show", "hide"];
@@ -43,8 +46,10 @@ export function watchWindowForPlacements(win) {
}
};
for (const name of events) win.on(name, send);
+ win.webContents.on("did-finish-load", send);
return () => {
for (const name of events) win.removeListener(name, send);
+ win.webContents.removeListener("did-finish-load", send);
};
}
diff --git a/apps/desktop/electron/placements-desktop.test.mjs b/apps/desktop/electron/placements-desktop.test.mjs
index 910c1014..9fcdb571 100644
--- a/apps/desktop/electron/placements-desktop.test.mjs
+++ b/apps/desktop/electron/placements-desktop.test.mjs
@@ -289,14 +289,16 @@ test("desktop: the window state goes to the page on focus, blur, minimize, resto
isMinimized: () => state.minimized,
isVisible: () => state.visible,
isDestroyed: () => false,
- webContents: { send: (channel, detail) => sent.push({ channel, detail }), isDestroyed: () => false },
+ webContents: { send: (channel, detail) => sent.push({ channel, detail }), isDestroyed: () => false, on: (name, fn) => handlers.set(`page:${name}`, fn), removeListener: (name) => handlers.delete(`page:${name}`) },
};
const off = watchWindowForPlacements(win);
- assert.deepEqual([...handlers.keys()].sort(), ["blur", "focus", "hide", "minimize", "restore", "show"]);
+ assert.deepEqual([...handlers.keys()].sort(), ["blur", "focus", "hide", "minimize", "page:did-finish-load", "restore", "show"]);
state.focused = false;
state.minimized = true;
handlers.get("minimize")();
assert.deepEqual(sent, [{ channel: WINDOW_STATE_CHANNEL, detail: { focused: false, minimized: true, visible: true } }]);
+ handlers.get("page:did-finish-load")();
+ assert.equal(sent.length, 2, "a (re)loaded page gets the state too");
off();
assert.equal(handlers.size, 0);
const preload = fs.readFileSync(path.join(here, "preload.mjs"), "utf8");