@webmobix/pulse-leo-sdk 0.0.1 → 0.2.1

package/dist/sw.js

@@ -1,21 +1,74 @@
-const n = self;
-n.addEventListener("install", (i) => {
-  console.log("[SW] Service Worker installing..."), i.waitUntil(n.skipWaiting());
+const r = "pulseleo-checkin", s = "https://pulseleo.internal/checkin-config.json";
+function l() {
+  return typeof caches < "u";
+}
+async function h() {
+  if (!l())
+    return null;
+  const t = await (await caches.open(r)).match(s);
+  if (!t)
+    return null;
+  try {
+    return await t.json();
+  } catch {
+    return null;
+  }
+}
+async function d(n) {
+  if (!l())
+    return;
+  await (await caches.open(r)).put(
+    s,
+    new Response(JSON.stringify(n), {
+      headers: { "Content-Type": "application/json" }
+    })
+  );
+}
+function p(n, t = Date.now()) {
+  if (!n.lastCheckinAt)
+    return !1;
+  const i = Date.parse(n.lastCheckinAt);
+  return Number.isNaN(i) ? !1 : t - i < 216e5;
+}
+async function w(n, t = Date.now()) {
+  try {
+    return (await fetch(n.checkinUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoint: n.endpoint })
+    })).ok ? (await d({
+      ...n,
+      lastCheckinAt: new Date(t).toISOString()
+    }), !0) : !1;
+  } catch {
+    return !1;
+  }
+}
+async function C(n = Date.now()) {
+  const t = await h();
+  return !t || p(t, n) ? !1 : w(t, n);
+}
+const e = self;
+e.addEventListener("install", (n) => {
+  console.log("[SW] Service Worker installing..."), n.waitUntil(e.skipWaiting());
 });
-n.addEventListener("activate", (i) => {
-  console.log("[SW] Service Worker activated"), i.waitUntil(n.clients.claim());
+e.addEventListener("activate", (n) => {
+  console.log("[SW] Service Worker activated"), n.waitUntil(e.clients.claim());
 });
-n.addEventListener("push", (i) => {
-  if (!i.data) {
-    console.warn("Push event received with no data.");
+e.addEventListener("push", (n) => {
+  if (!n.data) {
+    console.warn("[SW] Push event received with no data.");
     return;
   }
   try {
-    const t = i.data.json(), o = t.title || "Notification", a = {
+    const t = n.data.json(), i = t.title || "Notification", o = {
+      ...t.data,
+      url: t.clickUrl ?? t.url ?? t.data?.url
+    }, a = {
       body: t.body,
       icon: t.icon,
       badge: t.badge,
-      data: t.data,
+      data: o.url ? o : t.data ?? void 0,
       tag: t.tag,
       renotify: t.renotify,
       requireInteraction: t.requireInteraction,
@@ -27,29 +80,38 @@ n.addEventListener("push", (i) => {
       vibrate: t.vibrate,
       image: t.image
     };
-    i.waitUntil(n.registration.showNotification(o, a));
+    n.waitUntil(
+      Promise.all([
+        e.registration.showNotification(i, a),
+        // Record that this browser is alive. Failures are logged and
+        // swallowed: analytics must never break notification display.
+        C().catch(
+          (c) => console.warn("[SW] Check-in failed:", c)
+        )
+      ])
+    );
   } catch (t) {
-    console.error("Error handling push event:", t);
+    console.error("[SW] Error handling push event:", t);
   }
 });
-n.addEventListener("notificationclick", (i) => {
-  i.notification.close();
-  const t = i.notification.data?.url || "/", o = n.clients.matchAll({
+e.addEventListener("notificationclick", (n) => {
+  n.notification.close();
+  const t = n.notification.data?.url || "/", i = e.clients.matchAll({
     type: "window",
     includeUncontrolled: !0
-  }).then((a) => {
-    let e = null;
-    for (const r of a) {
-      const l = new URL(r.url, self.location.href), c = new URL(t, self.location.href);
-      if (l.href === c.href) {
-        e = r;
+  }).then((o) => {
+    let a = null;
+    for (const c of o) {
+      const f = new URL(c.url, self.location.href), u = new URL(t, self.location.href);
+      if (f.href === u.href) {
+        a = c;
         break;
       }
     }
-    if (e && "focus" in e)
-      return e.focus();
-    if (n.clients.openWindow)
-      return n.clients.openWindow(t);
+    if (a && "focus" in a)
+      return a.focus();
+    if (e.clients.openWindow)
+      return e.clients.openWindow(t);
   });
-  i.waitUntil(o);
+  n.waitUntil(i);
 });

package/dist/types.d.ts

@@ -1,29 +1,92 @@
+export interface PushNotificationPayload {
+    title?: string;
+    body?: string;
+    icon?: string;
+    badge?: string;
+    image?: string;
+    data?: Record<string, unknown>;
+    /** URL opened when the notification is clicked (shorthand for `data.url`). */
+    url?: string;
+    /** URL opened when the notification is clicked (set by the dashboard sender). */
+    clickUrl?: string;
+    tag?: string;
+    renotify?: boolean;
+    requireInteraction?: boolean;
+    silent?: boolean;
+    timestamp?: number;
+    actions?: Array<{
+        action: string;
+        title: string;
+        icon?: string;
+    }>;
+    dir?: NotificationDirection;
+    lang?: string;
+    vibrate?: number | number[];
+}
 /**
- * Options for initializing the PushClient
+ * The notification permission as reported by {@link PushClient.getPermissionState}.
+ * `"unsupported"` means the browser has no Web Push support at all (as opposed to
+ * `"denied"`, where the user refused).
  */
-export interface PushClientOptions {
+export type PermissionState = "granted" | "denied" | "default" | "unsupported";
+export interface PushClientRetryConfig {
+    maxAttempts?: number;
+    delayMs?: number;
+    backoffMultiplier?: number;
     /**
-     * The public VAPID key for the push service.
+     * Decides whether a failed relay call is retried. Receives the HTTP status
+     * of the failed response, or `undefined` for a network failure. Replaces the
+     * default policy (network errors, 408, 425, 429 and 5xx are retried; other
+     * statuses fail immediately) for both register and unregister calls.
      */
-    vapidPublicKey: string;
+    shouldRetry?: (status: number | undefined) => boolean;
+}
+/** Options for {@link PushClient.unsubscribe}. */
+export interface UnsubscribeOptions {
     /**
-     * The path to the service worker file (e.g., "/sw.js").
-     * Defaults to "/sw.js" if not provided.
+     * Whether to tell the backend (unregister relay) after removing the browser
+     * subscription. Defaults to `true`. Use `false` when no authenticated backend
+     * session exists any more (after logout, after a remote removal).
      */
+    notifyBackend?: boolean;
+}
+/** Options for {@link PushClient.register}. */
+export interface RegisterOptions {
+    /**
+     * When a browser subscription already exists, re-send it to the backend
+     * before resolving. Defaults to `false` (an existing subscription is left
+     * as is). Registration is an upsert keyed by endpoint, so this is idempotent.
+     */
+    force?: boolean;
+}
+export interface PushClientEndpoints {
+    register: string;
+    unregister?: string;
+}
+export interface PushClientOptions {
+    vapidPublicKey: string;
     serviceWorkerPath?: string;
+    backendRegisterUrl?: string;
+    endpoints?: PushClientEndpoints;
+    headers?: Record<string, string>;
+    getHeaders?: () => Promise<Record<string, string>> | Record<string, string>;
+    tags?: Record<string, string>;
     /**
-     * The URL of your backend endpoint that registers the subscription with PulseLeo.
+     * The URL of your backend endpoint that unregisters the subscription.
+     * Defaults to backendRegisterUrl with "/register" replaced by "/unregister".
      */
-    backendRegisterUrl: string;
+    backendUnregisterUrl?: string;
     /**
-     * Optional tags to associate with the subscription (key-value pairs).
-     * Example: { category: "news", plan: "premium" }
+     * The URL of your backend endpoint that records check-ins (activity
+     * analytics). Required for check-ins: push-receipt and periodic liveness
+     * reports only run when this is set, and a missing one fails loudly
+     * (CheckinConfigError) at registration and at startPeriodicCheckin call
+     * time. The URL is handed to the service worker so every received push
+     * can report liveness.
      */
-    tags?: Record<string, string>;
+    backendCheckinUrl?: string;
+    retry?: PushClientRetryConfig;
 }
-/**
- * Data structure required for push subscription
- */
 export interface PushSubscriptionData {
     endpoint: string;
     expirationTime?: number | null;

package/dist/utils.d.ts

@@ -1,12 +1,11 @@
 /**
- * Converts a VAPID public key (base64url string) to a Uint8Array.
- * @param base64String The base64url encoded VAPID public key.
- * @returns The Uint8Array representation of the key.
+ * Whether this environment can use Web Push: service workers, `PushManager` and
+ * `Notification` must all exist. Needs no client or configuration, so it can gate
+ * UI before a {@link PushClient} (or a VAPID key) exists. Returns `false` outside
+ * a browser.
  */
+export declare function isPushSupported(): boolean;
+export declare function isValidVapidKey(key: string): boolean;
+export declare function validateVapidKey(key: string): void;
 export declare function urlBase64ToUint8Array(base64String: string): Uint8Array;
-/**
- * Converts an ArrayBuffer or Uint8Array to a base64url string.
- * @param buffer The buffer to convert.
- * @returns The base64url string.
- */
 export declare function arrayBufferToUrlBase64(buffer: ArrayBuffer | Uint8Array): string;

package/dist/vapid.d.ts

@@ -0,0 +1,9 @@
+export interface VapidKeys {
+    publicKey: string;
+    privateKey: string;
+}
+/**
+ * Generates a valid VAPID P-256 key pair.
+ * Returns both keys as base64url strings.
+ */
+export declare function generateVapidKeys(): Promise<VapidKeys>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webmobix/pulse-leo-sdk",
-  "version": "0.0.1",
+  "version": "0.2.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -16,6 +16,21 @@
   "files": [
     "dist"
   ],
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webmobix/pulseleo-saas.git",
+    "directory": "packages/pulse-leo-sdk"
+  },
+  "homepage": "https://github.com/webmobix/pulseleo-saas/tree/main/packages/pulse-leo-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/webmobix/pulseleo-saas/issues"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && tsc -p tsconfig.worker.json && vite build && vite build -c vite.sw.config.ts && node scripts/verify-sw.mjs",
+    "test": "vitest run"
+  },
   "devDependencies": {
     "@playwright/test": "^1.56.1",
     "@types/node": "^22.19.1",
@@ -24,10 +39,5 @@
     "vite": "^7.2.4",
     "vite-plugin-dts": "^4.5.4",
     "vitest": "^4.0.13"
-  },
-  "scripts": {
-    "dev": "vite",
-    "build": "tsc && tsc -p tsconfig.worker.json && vite build",
-    "test": "vitest"
   }
-}
+}

package/dist/sw.d.ts

@@ -1 +0,0 @@
-export {}