The best way to control Claude Code, Codex and more from any computer or phone

main
ts 195 lines 6.37 KB
Raw
1 // @effect-diagnostics globalTimers:off globalDate:off - Render clocks for React hooks, outside an Effect runtime.
2
3 import type { EnvironmentId } from "@t3tools/contracts";
4
5 /**
6 * A `useSyncExternalStore`-shaped clock. Snapshots stay cached between
7 * notifications while subscribed, as `useSyncExternalStore` requires.
8 */
9 export interface ClockStore<A> {
10 readonly subscribe: (listener: () => void) => () => void;
11 readonly getSnapshot: () => A;
12 }
13
14 // setTimeout fires immediately for delays beyond a signed 32-bit int.
15 const MAX_TIMEOUT_MS = 2_147_483_647;
16
17 function makeTickStore<A>(read: () => A, periodMs: number): ClockStore<A> {
18 let value = read();
19 let timer: ReturnType<typeof setTimeout> | undefined;
20 const listeners = new Set<() => void>();
21
22 // Each tick lands on a wall-clock boundary so every subscriber updates in
23 // the same frame instead of each drifting on its own phase.
24 const schedule = () => {
25 timer = setTimeout(
26 () => {
27 timer = undefined;
28 const next = read();
29 if (next !== value) {
30 value = next;
31 for (const listener of listeners) listener();
32 }
33 // Listeners may unsubscribe (stopping the clock) or resubscribe (arming
34 // a fresh timer) while notified; only continue a clock nobody re-armed.
35 if (listeners.size > 0 && timer === undefined) schedule();
36 },
37 periodMs - (Date.now() % periodMs),
38 );
39 };
40
41 return {
42 subscribe: (listener) => {
43 if (listeners.size === 0) {
44 value = read();
45 schedule();
46 }
47 listeners.add(listener);
48 return () => {
49 listeners.delete(listener);
50 if (listeners.size === 0) {
51 clearTimeout(timer);
52 timer = undefined;
53 }
54 };
55 },
56 getSnapshot: () => {
57 if (timer === undefined) value = read();
58 return value;
59 },
60 };
61 }
62
63 /** Epoch ms floored to the second, advancing on each wall-clock second. */
64 export const secondTick: ClockStore<number> = makeTickStore(
65 () => Math.floor(Date.now() / 1000) * 1000,
66 1000,
67 );
68
69 /** ISO timestamp truncated to the minute (`YYYY-MM-DDTHH:mm`). */
70 export const minuteTick: ClockStore<string> = makeTickStore(
71 () => new Date().toISOString().slice(0, 16),
72 60_000,
73 );
74
75 // How far each environment's clock runs ahead of this one. Timers read it on
76 // every tick, so a reconnect's new reading lands without a re-render.
77 const serverClockOffsets = new Map<EnvironmentId, number>();
78
79 /**
80 * The host stamped `serverTimeMs` between the request and its reply, so the
81 * offset lies within that window. Keep the one nearest 0, so clocks that agree
82 * read as 0 instead of shifting every timer by network latency.
83 */
84 export function recordServerClock(
85 environmentId: EnvironmentId,
86 sample: {
87 readonly serverTimeMs: number | undefined;
88 readonly requestedAtMs: number;
89 readonly receivedAtMs: number;
90 },
91 ): void {
92 const { serverTimeMs, requestedAtMs, receivedAtMs } = sample;
93 if (serverTimeMs === undefined || !Number.isFinite(serverTimeMs)) {
94 serverClockOffsets.delete(environmentId);
95 return;
96 }
97 serverClockOffsets.set(
98 environmentId,
99 serverTimeMs > receivedAtMs
100 ? serverTimeMs - receivedAtMs
101 : serverTimeMs < requestedAtMs
102 ? serverTimeMs - requestedAtMs
103 : 0,
104 );
105 }
106
107 /** Converts client epoch milliseconds to the environment's clock. */
108 export function toServerClock(environmentId: EnvironmentId, clientMs: number): number {
109 return clientMs + (serverClockOffsets.get(environmentId) ?? 0);
110 }
111
112 export interface DeadlineStore extends ClockStore<boolean> {
113 /**
114 * Re-checks `Date.now()` and notifies if the deadline has passed. For callers
115 * that observe the deadline first, e.g. a click after a throttled or slept
116 * timer, so the snapshot catches up without waiting for the late timer.
117 */
118 readonly refresh: () => void;
119 }
120
121 const neverPassed: DeadlineStore = {
122 subscribe: () => () => {},
123 getSnapshot: () => false,
124 refresh: () => {},
125 };
126
127 interface DeadlineEntry {
128 readonly store: DeadlineStore;
129 readonly listeners: Set<() => void>;
130 passed: boolean;
131 timer: ReturnType<typeof setTimeout> | undefined;
132 }
133
134 // The single owner of each subscribed deadline. Handles obtained before the
135 // entry exists join it on subscribe, so they share its timer and notifications.
136 const deadlines = new Map<number, DeadlineEntry>();
137
138 function passDeadline(entry: DeadlineEntry) {
139 clearTimeout(entry.timer);
140 entry.timer = undefined;
141 entry.passed = true;
142 for (const listener of entry.listeners) listener();
143 }
144
145 function armDeadline(entry: DeadlineEntry, deadlineMs: number) {
146 const delay = deadlineMs - Date.now();
147 if (delay <= 0) {
148 passDeadline(entry);
149 return;
150 }
151 entry.timer = setTimeout(() => armDeadline(entry, deadlineMs), Math.min(delay, MAX_TIMEOUT_MS));
152 }
153
154 /** The epoch-ms deadline `delayMs` from now, for `deadlineStore`. */
155 export function deadlineAfter(delayMs: number): number {
156 return Date.now() + delayMs;
157 }
158
159 /**
160 * Whether `Date.now()` has reached `deadlineMs`. One timer per distinct
161 * deadline, shared by its subscribers; once passed the snapshot stays true.
162 * Deadlines register only while subscribed, so renders React discards leak nothing.
163 * A non-finite deadline never passes.
164 */
165 export function deadlineStore(deadlineMs: number | null): DeadlineStore {
166 if (deadlineMs === null || !Number.isFinite(deadlineMs)) return neverPassed;
167 const existing = deadlines.get(deadlineMs);
168 if (existing !== undefined) return existing.store;
169
170 const store: DeadlineStore = {
171 subscribe: (listener) => {
172 let entry = deadlines.get(deadlineMs);
173 if (entry === undefined) {
174 entry = { store, listeners: new Set(), passed: Date.now() >= deadlineMs, timer: undefined };
175 deadlines.set(deadlineMs, entry);
176 if (!entry.passed) armDeadline(entry, deadlineMs);
177 }
178 const joined = entry;
179 joined.listeners.add(listener);
180 return () => {
181 joined.listeners.delete(listener);
182 if (joined.listeners.size > 0) return;
183 clearTimeout(joined.timer);
184 joined.timer = undefined;
185 if (deadlines.get(deadlineMs) === joined) deadlines.delete(deadlineMs);
186 };
187 },
188 getSnapshot: () => deadlines.get(deadlineMs)?.passed ?? Date.now() >= deadlineMs,
189 refresh: () => {
190 const entry = deadlines.get(deadlineMs);
191 if (entry !== undefined && !entry.passed && Date.now() >= deadlineMs) passDeadline(entry);
192 },
193 };
194 return store;
195 }