Spaces:
Runtime error
Runtime error
| import { useEffect, useRef, useState } from "react"; | |
| /** | |
| * Calls `fn` every `intervalMs` until `until(result)` is true. Calls never overlap (each waits for the last), | |
| * it pauses while the tab is hidden, and it backs off after errors. Change `key` to restart it. | |
| * | |
| * `data`, `error` and `done` belong to the run (the `key`) that produced them: a new key or turning polling off reads | |
| * as a fresh start in the same render. Otherwise a caller's "finished?" check would still see the previous run's | |
| * `done` the moment a new run begins, and end it at once. | |
| */ | |
| export function usePoll<T>( | |
| fn: (() => Promise<T>) | null, | |
| { intervalMs, until, key }: { intervalMs: number; until: (t: T) => boolean; key?: unknown }, | |
| ): { data: T | null; error: unknown; done: boolean } { | |
| const [result, setResult] = useState<{ key: unknown; data: T | null; error: unknown; done: boolean } | null>(null); | |
| const fnRef = useRef(fn); | |
| const untilRef = useRef(until); | |
| fnRef.current = fn; | |
| untilRef.current = until; | |
| const enabled = fn !== null; | |
| useEffect(() => { | |
| if (!enabled) return; | |
| const runKey = key; | |
| let stopped = false; | |
| let timer: ReturnType<typeof setTimeout> | undefined; | |
| let failures = 0; | |
| setResult(null); // a re-enabled run with the same key starts clean too | |
| const tick = async () => { | |
| if (stopped) return; | |
| if (document.hidden) { | |
| timer = setTimeout(tick, intervalMs); | |
| return; | |
| } | |
| try { | |
| const next = await fnRef.current!(); | |
| if (stopped) return; | |
| failures = 0; | |
| const done = untilRef.current(next); | |
| setResult({ key: runKey, data: next, error: null, done }); | |
| if (done) return; | |
| } catch (e) { | |
| if (stopped) return; | |
| failures += 1; | |
| setResult((r) => ({ key: runKey, data: r !== null && r.key === runKey ? r.data : null, error: e, done: false })); | |
| } | |
| timer = setTimeout(tick, intervalMs * Math.min(2 ** failures, 8)); | |
| }; | |
| tick(); | |
| return () => { | |
| stopped = true; | |
| clearTimeout(timer); | |
| }; | |
| }, [enabled, intervalMs, key]); | |
| const mine = enabled && result !== null && result.key === key ? result : null; | |
| return { data: mine?.data ?? null, error: mine?.error ?? null, done: mine?.done ?? false }; | |
| } | |