The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 03:37 UTC
| 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 | } |