Files
clean-architecture-frontend…/src/adapters/web-push/runtime-support.ts
T

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;
}