@tokamakdev/plugin-notifications 0.1.0-beta.50

package/tokamak-plugin.json

@@ -0,0 +1,39 @@
+{
+  "schemaVersion": 1,
+  "id": "notifications",
+  "platforms": {
+    "macos": {
+      "class": "TokamakNotificationsPlugin",
+      "sources": ["apple/NotificationContent.swift", "apple/NotificationsPlugin.swift"],
+      "frameworks": ["UserNotifications"]
+    },
+    "ios": {
+      "class": "TokamakNotificationsPlugin",
+      "sources": ["apple/NotificationContent.swift", "apple/NotificationsPlugin.swift"],
+      "frameworks": ["UserNotifications"],
+      "plist": "apple/Info.plist"
+    },
+    "ios-simulator": {
+      "class": "TokamakNotificationsPlugin",
+      "sources": ["apple/NotificationContent.swift", "apple/NotificationsPlugin.swift"],
+      "frameworks": ["UserNotifications"],
+      "plist": "apple/Info.plist"
+    },
+    "android": {
+      "class": "com.tokamak.plugins.notifications.TokamakNotificationsPlugin",
+      "sources": [
+        "android/NotificationsPlugin.kt",
+        "android/Content.kt",
+        "android/Notifier.kt",
+        "android/Schedule.kt",
+        "android/Push.kt"
+      ],
+      "manifest": "android/AndroidManifest.xml",
+      "dependencies": ["com.google.firebase:firebase-messaging:25.1.3"],
+      "permissions": [
+        "android.permission.POST_NOTIFICATIONS",
+        "android.permission.RECEIVE_BOOT_COMPLETED"
+      ]
+    }
+  }
+}

package/web/index.ts

@@ -0,0 +1,180 @@
+import type {
+  Listener,
+  Message,
+  NotificationContent,
+  OpenedNotification,
+  Permission,
+  SubscribeOptions,
+  Subscription,
+} from "../src/index.js";
+import {
+  MESSAGE,
+  OPENED,
+  OPENED_CACHE,
+  SUBSCRIPTION,
+  type ServiceWorkerMessage,
+  notificationData,
+  pluginData,
+  webPushSubscription,
+} from "./protocol.js";
+
+export function permission(): Promise<Permission> {
+  return new Promise((resolve) => {
+    resolve(fromBrowserPermission(notificationApi().permission));
+  });
+}
+
+export async function requestPermission(): Promise<Permission> {
+  return fromBrowserPermission(await notificationApi().requestPermission());
+}
+
+export async function show(notification: NotificationContent): Promise<void> {
+  const api = notificationApi();
+  if (api.permission !== "granted") throw notAllowed();
+  const options = {
+    body: notification.body,
+    tag: notification.id,
+    data: notificationData("local", notification.data),
+  };
+  const registration = await serviceWorkerRegistration();
+  if (registration) {
+    await registration.showNotification(notification.title, options);
+    return;
+  }
+  try {
+    new api(notification.title, options);
+  } catch {
+    throw new DOMException("Showing notifications needs a service worker here", "NotSupportedError");
+  }
+}
+
+export function schedule(): Promise<void> {
+  return Promise.reject(
+    new DOMException("Scheduled notifications are not supported on the web", "NotSupportedError"),
+  );
+}
+
+export async function getDelivered(): Promise<NotificationContent[]> {
+  const registration = await serviceWorkerRegistration();
+  const shown = (await registration?.getNotifications()) ?? [];
+  return shown.flatMap((notification) => {
+    const data = pluginData(notification.data);
+    if (!data) return [];
+    return [{
+      id: notification.tag,
+      title: notification.title,
+      body: notification.body,
+      data: data.data,
+    }];
+  });
+}
+
+export async function remove(id: string): Promise<void> {
+  const registration = await serviceWorkerRegistration();
+  for (const notification of (await registration?.getNotifications({ tag: id })) ?? []) {
+    notification.close();
+  }
+}
+
+export async function subscribe(options: SubscribeOptions): Promise<Subscription> {
+  if (notificationApi().permission !== "granted") throw notAllowed();
+  const registration = await serviceWorkerRegistration();
+  if (!registration) {
+    throw new DOMException("Web Push needs a registered service worker", "InvalidStateError");
+  }
+  const existing = await registration.pushManager.getSubscription();
+  if (existing) return webPushSubscription(existing);
+  if (!options.applicationServerKey) {
+    throw new DOMException("Web Push needs the applicationServerKey option", "InvalidStateError");
+  }
+  const subscription = await registration.pushManager.subscribe({
+    userVisibleOnly: true,
+    applicationServerKey: options.applicationServerKey,
+  });
+  return webPushSubscription(subscription);
+}
+
+export async function getSubscription(): Promise<Subscription | null> {
+  const registration = await serviceWorkerRegistration();
+  const subscription = await registration?.pushManager.getSubscription();
+  return subscription ? webPushSubscription(subscription) : null;
+}
+
+export async function unsubscribe(): Promise<void> {
+  const registration = await serviceWorkerRegistration();
+  await (await registration?.pushManager.getSubscription())?.unsubscribe();
+}
+
+export function onMessage(listener: Listener<Message>): () => void {
+  return onServiceWorkerMessage((message) => {
+    if (message.type === MESSAGE) listener(message.message);
+  });
+}
+
+export function onSubscriptionChange(listener: Listener<Subscription>): () => void {
+  return onServiceWorkerMessage((message) => {
+    if (message.type === SUBSCRIPTION) listener(message.subscription);
+  });
+}
+
+const openedListeners = new Set<Listener<OpenedNotification>>();
+
+/** Delivers opened notifications the service worker holds, then each one it reports. */
+export function onNotificationOpened(listener: Listener<OpenedNotification>): () => void {
+  openedListeners.add(listener);
+  const stop = onServiceWorkerMessage((message) => {
+    if (message.type === OPENED) void takeOpened();
+  });
+  void takeOpened();
+  return () => {
+    openedListeners.delete(listener);
+    stop();
+  };
+}
+
+/** Takes each held notification once, even when several pages take them at once. */
+async function takeOpened(): Promise<void> {
+  if (openedListeners.size === 0 || !("caches" in globalThis)) return;
+  const cache = await caches.open(OPENED_CACHE);
+  for (const request of await cache.keys()) {
+    const response = await cache.match(request);
+    if (!response || !(await cache.delete(request))) continue;
+    const opened = (await response.json()) as OpenedNotification;
+    for (const listener of openedListeners) listener(opened);
+  }
+}
+
+function onServiceWorkerMessage(listener: Listener<ServiceWorkerMessage>): () => void {
+  const container = serviceWorkerContainer();
+  if (!container) return () => undefined;
+  const receive = (event: MessageEvent<ServiceWorkerMessage>) => {
+    listener(event.data);
+  };
+  container.addEventListener("message", receive);
+  return () => {
+    container.removeEventListener("message", receive);
+  };
+}
+
+function notificationApi(): typeof Notification {
+  const api = (globalThis as { Notification?: typeof Notification }).Notification;
+  if (api) return api;
+  throw new DOMException("Notifications are not supported here", "NotSupportedError");
+}
+
+function serviceWorkerContainer(): ServiceWorkerContainer | undefined {
+  return (globalThis as { navigator?: { serviceWorker?: ServiceWorkerContainer } }).navigator
+    ?.serviceWorker;
+}
+
+async function serviceWorkerRegistration(): Promise<ServiceWorkerRegistration | undefined> {
+  return serviceWorkerContainer()?.getRegistration();
+}
+
+function fromBrowserPermission(permission: NotificationPermission): Permission {
+  return permission === "default" ? "prompt" : permission;
+}
+
+function notAllowed(): DOMException {
+  return new DOMException("Notification permission has not been granted", "NotAllowedError");
+}

package/web/protocol.ts

@@ -0,0 +1,43 @@
+import type { Message, OpenedNotification, Subscription } from "../src/index.js";
+
+/** Messages the service worker helper posts to pages. */
+export const MESSAGE = "tokamak-notifications:message";
+export const OPENED = "tokamak-notifications:opened";
+export const SUBSCRIPTION = "tokamak-notifications:subscription";
+
+/** Holds opened notifications until a page takes them. */
+export const OPENED_CACHE = "tokamak-notifications-opened";
+
+/** What the plugin stores in `Notification.data`. */
+export interface NotificationData {
+  readonly tokamak: {
+    readonly source: OpenedNotification["source"];
+    readonly data: Record<string, unknown>;
+  };
+}
+
+export type ServiceWorkerMessage =
+  | { readonly type: typeof MESSAGE; readonly message: Message }
+  | { readonly type: typeof OPENED }
+  | { readonly type: typeof SUBSCRIPTION; readonly subscription: Subscription };
+
+export function notificationData(
+  source: OpenedNotification["source"],
+  data: Record<string, unknown> = {},
+): NotificationData {
+  return { tokamak: { source, data } };
+}
+
+/** The plugin's data on a notification it showed, or undefined for others. */
+export function pluginData(value: unknown): NotificationData["tokamak"] | undefined {
+  return (value as Partial<NotificationData> | null)?.tokamak;
+}
+
+export function webPushSubscription(subscription: PushSubscription): Subscription {
+  const { keys } = subscription.toJSON();
+  return {
+    service: "webpush",
+    endpoint: subscription.endpoint,
+    keys: { p256dh: keys?.p256dh ?? "", auth: keys?.auth ?? "" },
+  };
+}