138 lines
3.7 KiB
TypeScript
138 lines
3.7 KiB
TypeScript
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<typeof globalThis.setTimeout>,
|
|
);
|
|
},
|
|
});
|
|
|
|
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<Value>(
|
|
task: (signal: AbortSignal) => Promise<WebPushResult<Value>>,
|
|
input: Readonly<{
|
|
deadlineMs: number;
|
|
operation: WebPushOperation;
|
|
signal?: AbortSignal;
|
|
scheduler?: TimeoutScheduler;
|
|
}>,
|
|
): Promise<WebPushResult<Value>> {
|
|
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<Value>) => void)
|
|
| undefined;
|
|
const terminal = new Promise<WebPushResult<Value>>((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<WebPushObserver["record"]>[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<never> {
|
|
return webPushFailure("NATIVE_FAILURE", operation, retryable);
|
|
}
|
|
|
|
export function failureCode<Value>(
|
|
result: WebPushResult<Value>,
|
|
): WebPushFailureCode | undefined {
|
|
return result.ok ? undefined : result.error.code;
|
|
}
|