문제: browser-lifecycle.ts는 자신을 "창 lifecycle 리스너의 유일한
주인"이라 적고 어떤 capability도 visibilitychange·online·offline·focus·
pagehide·pageshow 리스너를 직접 달지 않는다고 약속한다.
optional-runtime-host.ts도 같은 말을 한다. 실제로는
- telemetry 수집기가 기본 구성에서 자기 pagehide 리스너를 단다
(telemetry-collector.ts onPageExit).
- 네이티브 파일 선택기가 선택 창이 열린 동안 window focus 리스너를
단다(browser-file-picker.ts, 리뷰가 세지 않은 두 번째 예외).
- lifecycle 런타임은 SW나 realtime이 있을 때만 만들어져 기본 구성에는
없다.
또 createBrowserLifecycleRuntime을 직접 부르는 테스트가 없어 bfcache
복원 때 generation 증가(K3), dispose 때 리스너 해제(K4) 변이가
살아남았다.
고른 방법: 리뷰 권고 (a). 주석을 "런타임이 있을 때 capability는 여기에
구독한다"로 좁히고, 런타임이 생기는 조건과 알려진 예외 둘을 적는다.
tests/unit/browser-lifecycle.test.ts를 추가해 리스너 수, generation,
visibility·connectivity, 구독자 격리, beforeunload 부착·해제·prompt,
dispose 뒤 0개를 확인한다.
버린 대안:
- (b) telemetry를 lifecycle 런타임에 연결하고 기본 구성에서도 런타임을
만든다: "기본 구성은 부작용 없는 생성" 원칙과 조립 순서를 함께 바꿔야
해 이번 범위를 넘는다.
- (c) lint로 이벤트 이름을 막고 예외 파일을 적는다: 예외 목록 관리 비용에
비해 지금 이득이 작다. 다운스트림이 lifecycle 런타임을 켤 때 다시 본다.
위험·한계: 규칙은 여전히 주석뿐이고 검사가 없다(주석에 그렇게 적었다).
src 동작은 바뀌지 않는다.
검증:
- RED(주석): 주석의 "single owner"와 telemetry-collector.ts의 pagehide,
browser-file-picker.ts의 focus 리스너를 대조해 불일치 확인.
- RED(테스트 공백): 새 테스트는 현재 코드에서 5/5 통과하고, 변이 4개를
모두 잡는다. K3(generation += 1 제거) → "expected {...} to match
object { generation: 2 }", K4(dispose의 pagehide·pageshow 해제 제거) →
"expected 2 to be +0", beforeunload 상시 부착 → "expected 1 to be +0",
dirty 검사 제거 → preventDefault "to not be called".
- 회귀: browser-lifecycle, optional-runtime-host, runtime-adapters
3파일 30/30 통과. tsc app·test 통과, eslint 통과,
check-adapter-inventory PASS.
Refs: docs/reviews/2026-11-01-maturity-review/05-adapters-storage-kernel.md
167 lines
5.2 KiB
TypeScript
167 lines
5.2 KiB
TypeScript
import { describe, expect, it, vi } from "vitest";
|
|
|
|
import {
|
|
createBrowserLifecycleRuntime,
|
|
type BrowserLifecycleEvent,
|
|
} from "../../src/adapters/platform/index.ts";
|
|
|
|
type Listener = (event: unknown) => void;
|
|
|
|
// 05-03. Records listeners per target so the test can count what the runtime
|
|
// attached and fire events without a DOM.
|
|
function createHost(initial: { hidden?: boolean; online?: boolean } = {}) {
|
|
const listeners = new Map<string, Set<Listener>>();
|
|
const target = (scope: string) => ({
|
|
addEventListener: (type: string, listener: Listener) => {
|
|
const key = `${scope}:${type}`;
|
|
const set = listeners.get(key) ?? new Set<Listener>();
|
|
set.add(listener);
|
|
listeners.set(key, set);
|
|
},
|
|
removeEventListener: (type: string, listener: Listener) => {
|
|
listeners.get(`${scope}:${type}`)?.delete(listener);
|
|
},
|
|
});
|
|
const document = {
|
|
...target("document"),
|
|
visibilityState: initial.hidden ? "hidden" : "visible",
|
|
};
|
|
const host = {
|
|
...target("window"),
|
|
document,
|
|
navigator: { onLine: initial.online ?? true },
|
|
};
|
|
const count = (key?: string) =>
|
|
[...listeners.entries()]
|
|
.filter(([name]) => key === undefined || name === key)
|
|
.reduce((total, [, set]) => total + set.size, 0);
|
|
const fire = (key: string, event: unknown = {}) => {
|
|
for (const listener of [...(listeners.get(key) ?? [])]) listener(event);
|
|
};
|
|
return { host, document, count, fire };
|
|
}
|
|
|
|
function create(initial?: Parameters<typeof createHost>[0]) {
|
|
const fake = createHost(initial);
|
|
const runtime = createBrowserLifecycleRuntime(
|
|
fake.host as unknown as Parameters<typeof createBrowserLifecycleRuntime>[0],
|
|
);
|
|
return { ...fake, runtime };
|
|
}
|
|
|
|
describe("browser lifecycle runtime", () => {
|
|
it("attaches one listener per lifecycle event and no beforeunload", () => {
|
|
const { count } = create();
|
|
for (const key of [
|
|
"document:visibilitychange",
|
|
"window:online",
|
|
"window:offline",
|
|
"window:focus",
|
|
"window:pagehide",
|
|
"window:pageshow",
|
|
]) {
|
|
expect(count(key)).toBe(1);
|
|
}
|
|
expect(count("window:beforeunload")).toBe(0);
|
|
expect(count()).toBe(6);
|
|
});
|
|
|
|
it("starts a new generation only on a bfcache restore", () => {
|
|
const { runtime, fire } = create();
|
|
const events: BrowserLifecycleEvent[] = [];
|
|
runtime.subscribe((event) => events.push(event));
|
|
|
|
expect(runtime.getSnapshot()).toMatchObject({
|
|
generation: 1,
|
|
pageState: "ACTIVE",
|
|
});
|
|
fire("window:pageshow", { persisted: false });
|
|
expect(runtime.getSnapshot()).toMatchObject({
|
|
generation: 1,
|
|
pageState: "ACTIVE",
|
|
});
|
|
|
|
fire("window:pagehide", { persisted: true });
|
|
expect(runtime.getSnapshot().pageState).toBe("PAGEHIDE");
|
|
fire("window:pageshow", { persisted: true });
|
|
expect(runtime.getSnapshot()).toMatchObject({
|
|
generation: 2,
|
|
pageState: "BFCACHE_RESTORED",
|
|
});
|
|
expect(events.map((event) => event.kind)).toEqual([
|
|
"PAGESHOW",
|
|
"PAGEHIDE",
|
|
"PAGESHOW",
|
|
]);
|
|
expect(events.at(-1)).toMatchObject({
|
|
persisted: true,
|
|
snapshot: { generation: 2 },
|
|
});
|
|
});
|
|
|
|
it("tracks visibility and connectivity and isolates a throwing subscriber", () => {
|
|
const { runtime, document, fire } = create({ hidden: true, online: false });
|
|
expect(runtime.getSnapshot()).toMatchObject({
|
|
visibility: "HIDDEN",
|
|
connectivityHint: "OFFLINE",
|
|
});
|
|
const received = vi.fn();
|
|
runtime.subscribe(() => {
|
|
throw new Error("subscriber defect");
|
|
});
|
|
runtime.subscribe(received);
|
|
|
|
document.visibilityState = "visible";
|
|
fire("document:visibilitychange");
|
|
fire("window:online");
|
|
expect(runtime.getSnapshot()).toMatchObject({
|
|
visibility: "VISIBLE",
|
|
connectivityHint: "ONLINE",
|
|
});
|
|
expect(received).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it("holds beforeunload only while a dirty source is registered", () => {
|
|
const { runtime, count, fire } = create();
|
|
let dirty = false;
|
|
const unregister = runtime.registerDirtySource(() => dirty);
|
|
const unregisterBroken = runtime.registerDirtySource(() => {
|
|
throw new Error("reporter defect");
|
|
});
|
|
expect(count("window:beforeunload")).toBe(1);
|
|
|
|
const clean = { preventDefault: vi.fn() };
|
|
fire("window:beforeunload", clean);
|
|
expect(clean.preventDefault).not.toHaveBeenCalled();
|
|
|
|
dirty = true;
|
|
const prompted = { preventDefault: vi.fn() };
|
|
fire("window:beforeunload", prompted);
|
|
expect(prompted.preventDefault).toHaveBeenCalledOnce();
|
|
|
|
unregister();
|
|
expect(count("window:beforeunload")).toBe(1);
|
|
unregisterBroken();
|
|
expect(count("window:beforeunload")).toBe(0);
|
|
});
|
|
|
|
it("removes every listener on dispose and ignores later subscriptions", () => {
|
|
const { runtime, count, fire } = create();
|
|
runtime.registerDirtySource(() => true);
|
|
const received = vi.fn();
|
|
runtime.subscribe(received);
|
|
expect(count()).toBe(7);
|
|
|
|
runtime.dispose();
|
|
expect(count()).toBe(0);
|
|
|
|
const late = vi.fn();
|
|
runtime.subscribe(late);
|
|
runtime.registerDirtySource(() => true);
|
|
fire("window:focus");
|
|
expect(count()).toBe(0);
|
|
expect(received).not.toHaveBeenCalled();
|
|
expect(late).not.toHaveBeenCalled();
|
|
});
|
|
});
|