Files
clean-architecture-frontend…/src/adapters/web-push/push-subscription-adapter.ts
T

1120 lines
33 KiB
TypeScript

import type { WebPushControlPort } from "../../application/ports/out/web-push-control.ts";
import {
WEB_PUSH_LIMITS,
samePushAuthority,
webPushFailure,
webPushSuccess,
type PushAuthoritySnapshot,
type PushControlV1,
type WebPushObserver,
type WebPushReadiness,
type WebPushResult,
type WebPushUnavailableReason,
} from "../../contracts/web-push.ts";
import type {
PushAssociationFenceStore,
PushControlReceipt,
} from "./push-association-fence-store.ts";
import {
decodeNotificationClickDataForCleanup,
} from "./push-codec.ts";
import type {
NativePushSubscriptionMaterial,
WebPushRegistrationCommit,
WebPushRegistrationGateway,
} from "./push-registration-gateway.ts";
import {
createLinkedAbortController,
observeWebPush,
withAbortableDeadline,
type TimeoutScheduler,
} from "./runtime-support.ts";
type PermissionState = "default" | "denied" | "granted";
type CapturedNativeSubscription =
| Readonly<{
captured: true;
subscription: WindowPushSubscriptionFacade | null;
}>
| Readonly<{ captured: false }>;
export type NotificationPermissionFacade = Readonly<{
permission(): PermissionState;
requestPermission(): Promise<PermissionState>;
}>;
export type WindowPushSubscriptionFacade = Readonly<{
endpoint: string;
expirationTime: number | null;
options: Readonly<{ applicationServerKey: ArrayBuffer | null }>;
getKey(name: "p256dh" | "auth"): ArrayBuffer | null;
unsubscribe(): Promise<boolean>;
}>;
export type WindowPushManagerFacade = Readonly<{
getSubscription(): Promise<WindowPushSubscriptionFacade | null>;
subscribe(input: Readonly<{
userVisibleOnly: true;
applicationServerKey: Uint8Array<ArrayBuffer>;
}>): Promise<WindowPushSubscriptionFacade>;
}>;
export type OwnedNotificationFacade = Readonly<{
data: unknown;
close(): void;
}>;
export type WindowServiceWorkerRegistrationFacade = Readonly<{
active: boolean;
pushManager: WindowPushManagerFacade;
getNotifications(): Promise<readonly OwnedNotificationFacade[]>;
}>;
export function createWebPushSubscriptionAdapter(
dependencies: Readonly<{
secureContext: boolean;
userActivationIsActive(): boolean;
permission: NotificationPermissionFacade;
registration: WindowServiceWorkerRegistrationFacade;
fenceStore: PushAssociationFenceStore;
gateway: WebPushRegistrationGateway;
vapidPublicKey: string;
now?: () => number;
idempotencyKeyFactory?: () => string;
nativeOperationDeadlineMs?: number;
backendOperationDeadlineMs?: number;
scheduler?: TimeoutScheduler;
observer?: WebPushObserver;
}>,
): WebPushControlPort {
const decodedVapidPublicKey = decodeVapidPublicKey(
dependencies.vapidPublicKey,
);
if (!decodedVapidPublicKey) {
throw new TypeError("Web Push VAPID public key is invalid.");
}
const vapidPublicKey: Uint8Array<ArrayBuffer> =
decodedVapidPublicKey;
const now = dependencies.now ?? Date.now;
const nativeOperationDeadlineMs =
dependencies.nativeOperationDeadlineMs ??
WEB_PUSH_LIMITS.nativeOperationDeadlineMs;
const backendOperationDeadlineMs =
dependencies.backendOperationDeadlineMs ??
WEB_PUSH_LIMITS.backendOperationDeadlineMs;
if (
!validDeadline(
nativeOperationDeadlineMs,
WEB_PUSH_LIMITS.nativeOperationDeadlineMs,
) ||
!validDeadline(
backendOperationDeadlineMs,
WEB_PUSH_LIMITS.backendOperationDeadlineMs,
)
) {
throw new TypeError("Web Push operation deadline is invalid.");
}
const idempotencyKeyFactory =
dependencies.idempotencyKeyFactory ?? (() => globalThis.crypto.randomUUID());
let closed = false;
let busy = false;
let lifecycleGeneration = 0;
const inFlight = new Set<
ReturnType<typeof createLinkedAbortController>
>();
const adapter: WebPushControlPort = {
inspect(input) {
return exclusive(
"SUBSCRIPTION_INSPECT",
input.signal,
async (generation, operationSignal) => {
const supported = supportReadiness();
if (supported) return webPushSuccess(supported);
const permission = permissionReadiness();
if (permission) return webPushSuccess(permission);
const native = await getSubscription(operationSignal, generation);
if (!native.ok) return native;
if (!native.value) {
return webPushSuccess(
unavailable("NATIVE_SUBSCRIPTION_MISSING"),
);
}
if (!subscriptionUsesKey(native.value, vapidPublicKey)) {
return webPushSuccess(
unavailable("SUBSCRIPTION_KEY_MISMATCH"),
);
}
const control = await dependencies.fenceStore.read({
signal: operationSignal,
});
if (!control.ok) return control;
return webPushSuccess(
isActiveFor(control.value?.control ?? null, input.authority)
? readiness("PUSH_READY")
: unavailable("SESSION_AUTHORITY_CHANGED"),
);
},
);
},
enable(input) {
return exclusive(
"SUBSCRIPTION_CREATE",
input.signal,
async (generation, operationSignal) => {
const supported = supportReadiness();
if (supported) return webPushSuccess(supported);
let permission = dependencies.permission.permission();
if (permission === "denied") {
await disableCurrentAssociation(
input.authority,
operationSignal,
generation,
);
return webPushSuccess(readiness("PUSH_DENIED"));
}
if (permission === "default") {
if (!dependencies.userActivationIsActive()) {
await disableCurrentAssociation(
input.authority,
operationSignal,
generation,
);
return webPushFailure(
"PERMISSION_DENIED",
"PERMISSION_REQUEST",
);
}
const requested = await boundedNative(
"PERMISSION_REQUEST",
operationSignal,
async (signal) => {
const value =
await dependencies.permission.requestPermission();
return signal.aborted
? webPushFailure("ABORTED", "PERMISSION_REQUEST")
: webPushSuccess(value);
},
);
if (!requested.ok) return requested;
permission = requested.value;
observeWebPush(dependencies.observer, {
event: "web_push_permission_finished",
outcome: permission === "granted" ? "SUCCEEDED" : "DEGRADED",
...(permission === "default"
? { reason: "PERMISSION_DISMISSED" }
: {}),
});
}
if (permission === "denied") {
await disableCurrentAssociation(
input.authority,
operationSignal,
generation,
);
return webPushSuccess(readiness("PUSH_DENIED"));
}
if (permission !== "granted") {
await disableCurrentAssociation(
input.authority,
operationSignal,
generation,
);
return webPushSuccess(
unavailable("PERMISSION_DISMISSED"),
);
}
const prepared = await dependencies.fenceStore.prepare({
authority: input.authority,
updatedAt: instantNow(),
signal: operationSignal,
});
if (!prepared.ok) return prepared;
const existing = await getSubscription(
operationSignal,
generation,
);
if (!existing.ok) return existing;
let subscription: WindowPushSubscriptionFacade;
let created = false;
if (existing.value) {
if (!subscriptionUsesKey(existing.value, vapidPublicKey)) {
await disableReceipt(
prepared.value,
input.authority,
operationSignal,
generation,
existing.value,
);
return webPushSuccess(
unavailable("SUBSCRIPTION_KEY_MISMATCH"),
);
}
subscription = existing.value;
} else {
const subscribed = await createSubscription(operationSignal);
if (!subscribed.ok) return subscribed;
subscription = subscribed.value;
created = true;
}
if (stale(operationSignal, generation)) {
if (created) void safeUnsubscribe(subscription);
return webPushFailure("ABORTED", "SUBSCRIPTION_CREATE");
}
return await registerAndActivate({
subscription,
prepared: prepared.value,
authority: input.authority,
signal: operationSignal,
generation,
created,
});
},
);
},
reconcile(input) {
return exclusive(
"SUBSCRIPTION_RECONCILE",
input.signal,
async (generation, operationSignal) => {
const supported = supportReadiness();
if (supported) return webPushSuccess(supported);
const permission = permissionReadiness();
if (permission) {
await disableCurrentAssociation(
input.authority,
operationSignal,
generation,
);
return webPushSuccess(permission);
}
const prepared = await dependencies.fenceStore.prepare({
authority: input.authority,
updatedAt: instantNow(),
signal: operationSignal,
});
if (!prepared.ok) return prepared;
const native = await getSubscription(
operationSignal,
generation,
);
if (!native.ok) return native;
if (!native.value) {
const revoked = await revokeMissingNative(
prepared.value,
input.authority,
operationSignal,
generation,
);
return revoked.ok
? webPushSuccess(
unavailable("NATIVE_SUBSCRIPTION_MISSING"),
)
: revoked;
}
if (!subscriptionUsesKey(native.value, vapidPublicKey)) {
await disableReceipt(
prepared.value,
input.authority,
operationSignal,
generation,
native.value,
);
return webPushSuccess(
unavailable("SUBSCRIPTION_KEY_MISMATCH"),
);
}
const material = captureNativeMaterial(native.value);
if (!material.ok) return material;
const reconciled = await boundedBackendReconcile({
material: material.value,
authority: input.authority,
signal: operationSignal,
});
if (!reconciled.ok) return reconciled;
if (stale(operationSignal, generation)) {
return webPushFailure("ABORTED", "SUBSCRIPTION_RECONCILE");
}
if (reconciled.value.state === "ABSENT") {
return await registerAndActivate({
subscription: native.value,
prepared: prepared.value,
authority: input.authority,
signal: operationSignal,
generation,
created: false,
});
}
return await activateCommit({
subscription: native.value,
prepared: prepared.value,
authority: input.authority,
commit: reconciled.value,
signal: operationSignal,
generation,
});
},
);
},
revoke(input) {
return exclusive(
"SUBSCRIPTION_REVOKE",
input.signal,
async (generation, operationSignal) => {
const current = await dependencies.fenceStore.read({
signal: operationSignal,
});
if (!current.ok) {
return webPushSuccess(unavailable("LOCAL_FENCE_UNSAFE"));
}
if (
!current.value ||
!samePushAuthority(
current.value.control,
input.previousAuthority,
)
) {
return webPushSuccess(unavailable("LOCAL_FENCE_UNSAFE"));
}
const capturedNative = await captureNativeForCleanup(
operationSignal,
generation,
);
const previousAssociation =
current.value.control.association.state === "UNASSOCIATED"
? null
: current.value.control.association.associationEpoch;
const fenced = await dependencies.fenceStore.rotateAndRevoke({
expectedRevision: current.value.revision,
previousAuthority: input.previousAuthority,
nextAuthority: input.nextAuthority,
updatedAt: instantNow(),
signal: operationSignal,
});
if (!fenced.ok) {
if (previousAssociation) {
await boundedBackendRevoke(previousAssociation);
}
return webPushSuccess(unavailable("LOCAL_FENCE_UNSAFE"));
}
let revokeAmbiguous = false;
if (previousAssociation) {
const backend = await boundedBackendRevoke(
previousAssociation,
);
revokeAmbiguous = !backend.ok;
}
const nativeClean = await cleanupNative(
previousAssociation,
generation,
capturedNative,
fenced.value,
);
observeWebPush(dependencies.observer, {
event: "web_push_association_revoked",
outcome:
revokeAmbiguous || !nativeClean ? "DEGRADED" : "SUCCEEDED",
...(revokeAmbiguous
? { reason: "BACKEND_REVOKE_AMBIGUOUS" }
: !nativeClean
? { reason: "NATIVE_UNSUBSCRIBE_AMBIGUOUS" }
: {}),
});
if (revokeAmbiguous) {
return webPushSuccess(
unavailable("BACKEND_REVOKE_AMBIGUOUS"),
);
}
if (!nativeClean) {
return webPushSuccess(
unavailable("NATIVE_UNSUBSCRIBE_AMBIGUOUS"),
);
}
return webPushSuccess(unavailable("REVOKED"));
},
);
},
dispose() {
if (closed) return;
closed = true;
lifecycleGeneration += 1;
for (const operation of inFlight) operation.abort();
inFlight.clear();
try {
dependencies.fenceStore.close();
} catch {
// The lifecycle is terminal even if host cleanup throws.
}
},
};
return Object.freeze(adapter);
async function exclusive(
failureOperation:
| "SUBSCRIPTION_INSPECT"
| "SUBSCRIPTION_CREATE"
| "SUBSCRIPTION_RECONCILE"
| "SUBSCRIPTION_REVOKE",
signal: AbortSignal | undefined,
task: (
generation: number,
operationSignal: AbortSignal,
) => Promise<WebPushResult<WebPushReadiness>>,
): Promise<WebPushResult<WebPushReadiness>> {
if (closed) return webPushSuccess(unavailable("CLOSED"));
if (busy) return webPushSuccess(unavailable("BUSY"));
if (signal?.aborted) {
return webPushFailure("ABORTED", "SUBSCRIPTION_INSPECT");
}
busy = true;
const generation = lifecycleGeneration;
const operation = createLinkedAbortController(signal);
inFlight.add(operation);
try {
try {
return await task(generation, operation.signal);
} catch {
return webPushFailure(
"NATIVE_FAILURE",
failureOperation,
true,
);
}
} finally {
operation.dispose();
inFlight.delete(operation);
busy = false;
}
}
function supportReadiness(): WebPushReadiness | null {
if (!dependencies.secureContext) {
return readiness("PUSH_UNSUPPORTED");
}
if (!dependencies.registration.active) {
return unavailable("REGISTRATION_NOT_ACTIVE");
}
return null;
}
function permissionReadiness(): WebPushReadiness | null {
const permission = dependencies.permission.permission();
if (permission === "denied") return readiness("PUSH_DENIED");
if (permission === "default") {
return readiness("PUSH_PERMISSION_REQUIRED");
}
return null;
}
async function getSubscription(
signal: AbortSignal | undefined,
generation: number,
): Promise<WebPushResult<WindowPushSubscriptionFacade | null>> {
return await boundedNative(
"SUBSCRIPTION_INSPECT",
signal,
async (boundedSignal) => {
const subscription =
await dependencies.registration.pushManager.getSubscription();
return boundedSignal.aborted || stale(signal, generation)
? webPushFailure("ABORTED", "SUBSCRIPTION_INSPECT")
: webPushSuccess(subscription);
},
);
}
async function createSubscription(
signal: AbortSignal,
): Promise<WebPushResult<WindowPushSubscriptionFacade>> {
return await boundedNative(
"SUBSCRIPTION_CREATE",
signal,
async (boundedSignal) => {
const subscription =
await dependencies.registration.pushManager.subscribe({
userVisibleOnly: true,
applicationServerKey: vapidPublicKey,
});
if (boundedSignal.aborted) {
void safeUnsubscribe(subscription);
return webPushFailure("ABORTED", "SUBSCRIPTION_CREATE");
}
return webPushSuccess(subscription);
},
);
}
async function boundedNative<Value>(
operation:
| "PERMISSION_REQUEST"
| "SUBSCRIPTION_INSPECT"
| "SUBSCRIPTION_CREATE",
signal: AbortSignal | undefined,
task: (
boundedSignal: AbortSignal,
) => Promise<WebPushResult<Value>>,
): Promise<WebPushResult<Value>> {
return await withAbortableDeadline(task, {
deadlineMs: nativeOperationDeadlineMs,
operation,
signal,
scheduler: dependencies.scheduler,
});
}
async function boundedBackendRegister(
input: Parameters<WebPushRegistrationGateway["register"]>[0],
): ReturnType<WebPushRegistrationGateway["register"]> {
return await withAbortableDeadline(
async (signal) => {
const registered = await dependencies.gateway.register({
...input,
signal,
});
if (signal.aborted && registered.ok) {
void boundedBackendRevoke(
registered.value.associationEpoch,
);
return webPushFailure("ABORTED", "SUBSCRIPTION_CREATE");
}
return registered;
},
{
deadlineMs: backendOperationDeadlineMs,
operation: "SUBSCRIPTION_CREATE",
signal: input.signal,
scheduler: dependencies.scheduler,
},
);
}
async function boundedBackendReconcile(
input: Parameters<WebPushRegistrationGateway["reconcile"]>[0],
): ReturnType<WebPushRegistrationGateway["reconcile"]> {
return await withAbortableDeadline(
(signal) =>
dependencies.gateway.reconcile({
...input,
signal,
}),
{
deadlineMs: backendOperationDeadlineMs,
operation: "SUBSCRIPTION_RECONCILE",
signal: input.signal,
scheduler: dependencies.scheduler,
},
);
}
async function boundedBackendRevoke(
associationEpoch: string,
signal?: AbortSignal,
): ReturnType<WebPushRegistrationGateway["revoke"]> {
return await withAbortableDeadline(
(boundedSignal) =>
dependencies.gateway.revoke({
associationEpoch,
signal: boundedSignal,
}),
{
deadlineMs: backendOperationDeadlineMs,
operation: "SUBSCRIPTION_REVOKE",
signal,
scheduler: dependencies.scheduler,
},
);
}
async function registerAndActivate(input: Readonly<{
subscription: WindowPushSubscriptionFacade;
prepared: PushControlReceipt;
authority: PushAuthoritySnapshot;
signal: AbortSignal | undefined;
generation: number;
created: boolean;
}>): Promise<WebPushResult<WebPushReadiness>> {
const material = captureNativeMaterial(input.subscription);
if (!material.ok) {
if (input.created) void safeUnsubscribe(input.subscription);
return material;
}
let idempotencyKey: string;
try {
idempotencyKey = idempotencyKeyFactory();
} catch {
if (input.created) void safeUnsubscribe(input.subscription);
return webPushFailure("NATIVE_FAILURE", "SUBSCRIPTION_CREATE");
}
const registered = await boundedBackendRegister({
material: material.value,
authority: input.authority,
idempotencyKey,
signal: input.signal,
});
if (!registered.ok) {
if (input.created) void safeUnsubscribe(input.subscription);
return registered;
}
observeWebPush(dependencies.observer, {
event: "web_push_registration_finished",
outcome: "SUCCEEDED",
});
return await activateCommit({
subscription: input.subscription,
prepared: input.prepared,
authority: input.authority,
commit: registered.value,
signal: input.signal,
generation: input.generation,
});
}
async function activateCommit(input: Readonly<{
subscription: WindowPushSubscriptionFacade;
prepared: PushControlReceipt;
authority: PushAuthoritySnapshot;
commit: WebPushRegistrationCommit;
signal: AbortSignal | undefined;
generation: number;
}>): Promise<WebPushResult<WebPushReadiness>> {
if (
input.commit.sessionBindingEpoch !==
input.authority.sessionBindingEpoch ||
stale(input.signal, input.generation)
) {
await compensate(input.subscription, input.commit.associationEpoch);
return webPushSuccess(
unavailable("SESSION_AUTHORITY_CHANGED"),
);
}
const activated = await dependencies.fenceStore.activate({
expectedRevision: input.prepared.revision,
authority: input.authority,
associationEpoch: input.commit.associationEpoch,
updatedAt: instantNow(),
signal: input.signal,
});
if (!activated.ok) {
await compensate(input.subscription, input.commit.associationEpoch);
return webPushSuccess(unavailable("LOCAL_FENCE_UNSAFE"));
}
return webPushSuccess(readiness("PUSH_READY"));
}
async function compensate(
subscription: WindowPushSubscriptionFacade,
associationEpoch: string,
): Promise<void> {
await withAbortableDeadline(
async (signal) => {
await Promise.allSettled([
boundedBackendRevoke(associationEpoch, signal),
safeUnsubscribe(subscription),
]);
return webPushSuccess(undefined);
},
{
deadlineMs: WEB_PUSH_LIMITS.notificationCleanupDeadlineMs,
operation: "SUBSCRIPTION_REVOKE",
scheduler: dependencies.scheduler,
},
);
}
async function revokeMissingNative(
current: PushControlReceipt,
authority: PushAuthoritySnapshot,
signal: AbortSignal | undefined,
generation: number,
): Promise<WebPushResult<void>> {
if (current.control.association.state === "UNASSOCIATED") {
return webPushSuccess(undefined);
}
let fenced = current;
if (current.control.association.state === "ACTIVE") {
const marked = await dependencies.fenceStore.markRevoked({
expectedRevision: current.revision,
authority,
updatedAt: instantNow(),
signal,
});
if (!marked.ok) {
await boundedBackendRevoke(
current.control.association.associationEpoch,
);
return marked;
}
fenced = marked.value;
}
const backend = await boundedBackendRevoke(
current.control.association.associationEpoch,
);
await cleanupNative(
current.control.association.associationEpoch,
generation,
Object.freeze({
captured: true,
subscription: null,
}),
fenced,
);
return backend.ok ? webPushSuccess(undefined) : backend;
}
async function disableCurrentAssociation(
authority: PushAuthoritySnapshot,
signal: AbortSignal | undefined,
generation: number,
): Promise<boolean> {
const current = await dependencies.fenceStore.read({ signal });
if (
!current.ok ||
!current.value ||
!samePushAuthority(current.value.control, authority)
) {
return false;
}
return await disableReceipt(
current.value,
authority,
signal,
generation,
);
}
async function disableReceipt(
current: PushControlReceipt,
authority: PushAuthoritySnapshot,
signal: AbortSignal | undefined,
generation: number,
knownSubscription?: WindowPushSubscriptionFacade,
): Promise<boolean> {
const association =
current.control.association.state === "UNASSOCIATED"
? null
: current.control.association.associationEpoch;
const capturedNative =
knownSubscription === undefined
? await captureNativeForCleanup(signal, generation)
: Object.freeze({
captured: true as const,
subscription: knownSubscription,
});
let fenced = current;
if (current.control.association.state === "ACTIVE") {
const marked = await dependencies.fenceStore.markRevoked({
expectedRevision: current.revision,
authority,
updatedAt: instantNow(),
signal,
});
if (!marked.ok) {
if (association) await boundedBackendRevoke(association);
return false;
}
fenced = marked.value;
}
const backendSafe = association
? (await boundedBackendRevoke(association)).ok
: true;
const nativeSafe = await cleanupNative(
association,
generation,
capturedNative,
fenced,
);
return backendSafe && nativeSafe;
}
async function captureNativeForCleanup(
signal: AbortSignal | undefined,
generation: number,
): Promise<CapturedNativeSubscription> {
const native = await getSubscription(signal, generation);
return native.ok
? Object.freeze({
captured: true as const,
subscription: native.value,
})
: Object.freeze({ captured: false as const });
}
async function cleanupNative(
associationEpoch: string | null,
generation: number,
capturedNative: CapturedNativeSubscription,
expectedFence: PushControlReceipt,
): Promise<boolean> {
const cleanup = await withAbortableDeadline(
async (signal) => {
if (stale(signal, generation)) {
return webPushSuccess(false);
}
const currentFence = await dependencies.fenceStore.read({
signal,
});
if (
stale(signal, generation) ||
!currentFence.ok ||
!sameCleanupFence(currentFence.value, expectedFence)
) {
return webPushSuccess(false);
}
const unsubscribe = !capturedNative.captured
? Promise.resolve(false)
: capturedNative.subscription
? safeUnsubscribe(capturedNative.subscription)
: Promise.resolve(true);
const [nativeResult, notificationResult] =
await Promise.allSettled([
unsubscribe,
associationEpoch === null
? Promise.resolve(webPushSuccess(undefined))
: closeOwnedNotifications(
associationEpoch,
signal,
generation,
),
]);
const nativeClean =
nativeResult.status === "fulfilled" &&
nativeResult.value;
const notificationsClean =
notificationResult.status === "fulfilled" &&
notificationResult.value.ok;
return webPushSuccess(
nativeClean && notificationsClean,
);
},
{
deadlineMs: WEB_PUSH_LIMITS.notificationCleanupDeadlineMs,
operation: "NOTIFICATION_CLEANUP",
scheduler: dependencies.scheduler,
},
);
return cleanup.ok && cleanup.value;
}
async function closeOwnedNotifications(
associationEpoch: string,
signal: AbortSignal | undefined,
generation: number,
): Promise<WebPushResult<void>> {
let notifications: readonly OwnedNotificationFacade[];
try {
notifications = await dependencies.registration.getNotifications();
} catch {
return webPushFailure(
"NATIVE_FAILURE",
"NOTIFICATION_CLEANUP",
true,
);
}
if (stale(signal, generation)) {
return webPushFailure("ABORTED", "NOTIFICATION_CLEANUP");
}
for (const notification of notifications.slice(
0,
WEB_PUSH_LIMITS.notificationCleanupCount,
)) {
const decoded = decodeNotificationClickDataForCleanup(
notification.data,
);
if (
decoded.ok &&
decoded.value.associationEpoch === associationEpoch
) {
try {
notification.close();
} catch {
// Closing an OS notification is best effort.
}
}
}
return webPushSuccess(undefined);
}
function stale(
signal: AbortSignal | undefined,
generation: number,
): boolean {
return (
Boolean(signal?.aborted) ||
closed ||
generation !== lifecycleGeneration
);
}
function instantNow(): string {
const value = now();
return Number.isFinite(value)
? new Date(value).toISOString()
: new Date(0).toISOString();
}
}
function readiness(
state: WebPushReadiness["state"],
): WebPushReadiness {
return Object.freeze({ state });
}
function unavailable(
reason: WebPushUnavailableReason,
): WebPushReadiness {
return Object.freeze({ state: "PUSH_UNAVAILABLE", reason });
}
function sameCleanupFence(
current: PushControlReceipt | null,
expected: PushControlReceipt,
): boolean {
if (
!current ||
current.revision !== expected.revision ||
!samePushAuthority(current.control, expected.control) ||
current.control.association.state !==
expected.control.association.state
) {
return false;
}
return current.control.association.state === "UNASSOCIATED"
? true
: expected.control.association.state !== "UNASSOCIATED" &&
current.control.association.associationEpoch ===
expected.control.association.associationEpoch;
}
function validDeadline(value: number, ceiling: number): boolean {
return (
Number.isSafeInteger(value) &&
value >= 1 &&
value <= ceiling
);
}
function isActiveFor(
value: PushControlV1 | null,
authority: PushAuthoritySnapshot,
): boolean {
return (
Boolean(value) &&
value?.association.state === "ACTIVE" &&
samePushAuthority(value, authority)
);
}
function captureNativeMaterial(
subscription: WindowPushSubscriptionFacade,
): WebPushResult<NativePushSubscriptionMaterial> {
let p256dh: ArrayBuffer | null;
let auth: ArrayBuffer | null;
try {
p256dh = subscription.getKey("p256dh");
auth = subscription.getKey("auth");
} catch {
return webPushFailure("NATIVE_FAILURE", "SUBSCRIPTION_INSPECT");
}
if (!p256dh || !auth || p256dh.byteLength !== 65 || auth.byteLength !== 16) {
return webPushFailure("CONTRACT_REJECTED", "SUBSCRIPTION_INSPECT");
}
return webPushSuccess(
Object.freeze({
endpoint: subscription.endpoint,
p256dh: base64UrlEncode(new Uint8Array(p256dh)),
auth: base64UrlEncode(new Uint8Array(auth)),
expirationTime: subscription.expirationTime,
}),
);
}
function subscriptionUsesKey(
subscription: WindowPushSubscriptionFacade,
expected: Uint8Array<ArrayBuffer>,
): boolean {
const current = subscription.options.applicationServerKey;
if (!current || current.byteLength !== expected.byteLength) return false;
const bytes = new Uint8Array(current);
let difference = 0;
for (let index = 0; index < bytes.length; index += 1) {
difference |= bytes[index]! ^ expected[index]!;
}
return difference === 0;
}
async function safeUnsubscribe(
subscription: WindowPushSubscriptionFacade,
): Promise<boolean> {
try {
return await subscription.unsubscribe();
} catch {
return false;
}
}
function decodeVapidPublicKey(
value: string,
): Uint8Array<ArrayBuffer> | null {
if (!/^[A-Za-z0-9_-]{87}$/u.test(value)) return null;
const decoded = base64UrlDecode(value);
return decoded?.byteLength === 65 && decoded[0] === 4 ? decoded : null;
}
function base64UrlDecode(value: string): Uint8Array<ArrayBuffer> | null {
const alphabet =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
const outputLength = Math.floor((value.length * 6) / 8);
const output = new Uint8Array(new ArrayBuffer(outputLength));
let accumulator = 0;
let bitCount = 0;
let outputIndex = 0;
for (const character of value) {
const digit = alphabet.indexOf(character);
if (digit < 0) return null;
accumulator = (accumulator << 6) | digit;
bitCount += 6;
if (bitCount >= 8) {
bitCount -= 8;
output[outputIndex] = (accumulator >>> bitCount) & 0xff;
outputIndex += 1;
}
}
if (
outputIndex !== outputLength ||
(bitCount > 0 && (accumulator & ((1 << bitCount) - 1)) !== 0)
) {
return null;
}
return output;
}
function base64UrlEncode(bytes: Uint8Array): string {
const alphabet =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
let output = "";
let accumulator = 0;
let bitCount = 0;
for (const byte of bytes) {
accumulator = (accumulator << 8) | byte;
bitCount += 8;
while (bitCount >= 6) {
bitCount -= 6;
output += alphabet[(accumulator >>> bitCount) & 63];
}
}
if (bitCount > 0) {
output += alphabet[(accumulator << (6 - bitCount)) & 63];
}
return output;
}