import { webPushFailure, type WebPushFailureCode, type WebPushObserver, type WebPushOperation, type WebPushResult, } from "../../contracts/web-push.ts"; export type TimeoutScheduler = Readonly<{ setTimeout(callback: () => void, milliseconds: number): unknown; clearTimeout(handle: unknown): void; }>; export const systemTimeoutScheduler: TimeoutScheduler = Object.freeze({ setTimeout(callback, milliseconds) { return globalThis.setTimeout(callback, milliseconds); }, clearTimeout(handle) { globalThis.clearTimeout( handle as ReturnType, ); }, }); export type LinkedAbortController = Readonly<{ signal: AbortSignal; abort(): void; dispose(): void; }>; export function createLinkedAbortController( source?: AbortSignal, ): LinkedAbortController { const controller = new AbortController(); const abort = () => controller.abort(); if (source?.aborted) { controller.abort(); } else { source?.addEventListener("abort", abort, { once: true }); if (source?.aborted) abort(); } return Object.freeze({ signal: controller.signal, abort, dispose() { source?.removeEventListener("abort", abort); }, }); } export async function withAbortableDeadline( task: (signal: AbortSignal) => Promise>, input: Readonly<{ deadlineMs: number; operation: WebPushOperation; signal?: AbortSignal; scheduler?: TimeoutScheduler; }>, ): Promise> { if (input.signal?.aborted) { return webPushFailure("ABORTED", input.operation); } const scheduler = input.scheduler ?? systemTimeoutScheduler; const controller = new AbortController(); let timeoutHandle: unknown; let settleTerminal: | ((result: WebPushResult) => void) | undefined; const terminal = new Promise>((resolve) => { settleTerminal = resolve; }); const abortFromCaller = () => { controller.abort(); settleTerminal?.(webPushFailure("ABORTED", input.operation)); }; input.signal?.addEventListener("abort", abortFromCaller, { once: true, }); if (input.signal?.aborted) abortFromCaller(); try { timeoutHandle = scheduler.setTimeout(() => { controller.abort(); settleTerminal?.( webPushFailure("DEADLINE_EXCEEDED", input.operation), ); }, input.deadlineMs); } catch { controller.abort(); input.signal?.removeEventListener("abort", abortFromCaller); return webPushFailure( "NATIVE_FAILURE", input.operation, true, ); } const execution = Promise.resolve() .then(() => controller.signal.aborted ? webPushFailure("ABORTED", input.operation) : task(controller.signal), ) .catch(() => webPushFailure("NATIVE_FAILURE", input.operation, true)); try { return await Promise.race([execution, terminal]); } finally { try { scheduler.clearTimeout(timeoutHandle); } catch { // A host cleanup failure cannot replace the settled closed result. } input.signal?.removeEventListener("abort", abortFromCaller); } } export function observeWebPush( observer: WebPushObserver | undefined, input: Parameters[0], ): void { try { observer?.record(Object.freeze({ ...input })); } catch { // Capability correctness is independent from best-effort observation. } } export function nativeFailure( operation: WebPushOperation, retryable = true, ): WebPushResult { return webPushFailure("NATIVE_FAILURE", operation, retryable); } export function failureCode( result: WebPushResult, ): WebPushFailureCode | undefined { return result.ok ? undefined : result.error.code; }