@webmobix/pulse-leo-sdk 0.0.1 → 0.2.1

package/dist/index.js

@@ -1,125 +1,491 @@
-function o(n) {
-  const e = "=".repeat((4 - n.length % 4) % 4), i = (n + e).replace(/-/g, "+").replace(/_/g, "/"), r = atob(i), s = new Uint8Array(r.length);
-  for (let t = 0; t < r.length; ++t)
-    s[t] = r.charCodeAt(t);
-  return s;
-}
-function a(n) {
-  const e = new Uint8Array(n);
-  let i = "";
-  for (let r = 0; r < e.byteLength; r++)
-    i += String.fromCharCode(e[r]);
-  return btoa(i).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var y = /* @__PURE__ */ ((i) => (i.PERMISSION_DENIED = "PERMISSION_DENIED", i.SUBSCRIPTION_FAILED = "SUBSCRIPTION_FAILED", i.INVALID_VAPID_KEY = "INVALID_VAPID_KEY", i.UNSUBSCRIPTION_FAILED = "UNSUBSCRIPTION_FAILED", i.BACKEND_REGISTRATION_FAILED = "BACKEND_REGISTRATION_FAILED", i.CHECKIN_CONFIG_MISSING = "CHECKIN_CONFIG_MISSING", i.NOT_SUPPORTED = "NOT_SUPPORTED", i))(y || {});
+class o extends Error {
+  code;
+  constructor(e, t, r) {
+    super(t, r), this.name = "PushClientError", this.code = e, Object.setPrototypeOf(this, o.prototype);
+  }
 }
-class c {
-  config;
+class f extends o {
+  constructor(e = "Notification permission was denied", t) {
+    super("PERMISSION_DENIED", e, t), this.name = "PermissionDeniedError", Object.setPrototypeOf(this, f.prototype);
+  }
+}
+class u extends o {
+  constructor(e, t) {
+    super("SUBSCRIPTION_FAILED", e, t), this.name = "SubscriptionError", Object.setPrototypeOf(this, u.prototype);
+  }
+}
+class g extends o {
+  constructor(e, t) {
+    super("INVALID_VAPID_KEY", e, t), this.name = "ValidationError", Object.setPrototypeOf(this, g.prototype);
+  }
+}
+class P extends o {
+  constructor(e, t) {
+    super("UNSUBSCRIPTION_FAILED", e, t), this.name = "UnsubscriptionError", Object.setPrototypeOf(this, P.prototype);
+  }
+}
+class b extends o {
   /**
-   * Creates an instance of PushClient.
-   * @param config - The configuration options for the client.
+   * HTTP status code of the last failed relay response, or `undefined` when
+   * the last failure was not an HTTP response (network error, timeout).
    */
+  status;
+  constructor(e, t) {
+    super("BACKEND_REGISTRATION_FAILED", e, t), this.name = "BackendRegistrationError", this.status = t?.status, Object.setPrototypeOf(this, b.prototype);
+  }
+}
+class d extends o {
+  constructor(e = "backendCheckinUrl is required for check-in analytics", t) {
+    super("CHECKIN_CONFIG_MISSING", e, t), this.name = "CheckinConfigError", Object.setPrototypeOf(this, d.prototype);
+  }
+}
+class p extends o {
+  constructor(e = "Push notifications are not supported in this browser", t) {
+    super("NOT_SUPPORTED", e, t), this.name = "NotSupportedError", Object.setPrototypeOf(this, p.prototype);
+  }
+}
+function R() {
+  return typeof window < "u" && typeof navigator < "u" && "serviceWorker" in navigator && !!navigator.serviceWorker && "PushManager" in window && "Notification" in window;
+}
+const E = /^[A-Za-z0-9_-]+$/;
+function N(i) {
+  if (!i || i.length === 0 || !E.test(i))
+    return !1;
+  const e = (4 - i.length % 4) % 4, t = i.length + e;
+  return !(t < 87 || t > 256);
+}
+function T(i) {
+  return !!i && i.length > 0 && E.test(i);
+}
+function F(i) {
+  if (!N(i))
+    throw new g(
+      "Invalid VAPID key format. Expected base64url-encoded string between 87 and 256 characters."
+    );
+}
+function I(i) {
+  if (!T(i))
+    throw new g(
+      "Invalid VAPID key format. Expected base64url-encoded string between 1 and 256 characters."
+    );
+  const e = "=".repeat((4 - i.length % 4) % 4), t = (i + e).replace(/-/g, "+").replace(/_/g, "/"), r = atob(t), n = new Uint8Array(r.length);
+  for (let s = 0; s < r.length; ++s)
+    n[s] = r.charCodeAt(s);
+  return n;
+}
+function A(i) {
+  const e = new Uint8Array(i);
+  let t = "";
+  for (let r = 0; r < e.byteLength; r++)
+    t += String.fromCharCode(e[r]);
+  return btoa(t).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+const w = "pulseleo-checkin", k = "https://pulseleo.internal/checkin-config.json", D = 360 * 60 * 1e3;
+function C() {
+  return typeof caches < "u";
+}
+async function U() {
+  if (!C())
+    return null;
+  const e = await (await caches.open(w)).match(k);
+  if (!e)
+    return null;
+  try {
+    return await e.json();
+  } catch {
+    return null;
+  }
+}
+async function O(i) {
+  if (!C())
+    return;
+  await (await caches.open(w)).put(
+    k,
+    new Response(JSON.stringify(i), {
+      headers: { "Content-Type": "application/json" }
+    })
+  );
+}
+async function _() {
+  if (!C())
+    return;
+  await (await caches.open(w)).delete(k);
+}
+function K(i, e = Date.now()) {
+  if (!i.lastCheckinAt)
+    return !1;
+  const t = Date.parse(i.lastCheckinAt);
+  return Number.isNaN(t) ? !1 : e - t < D;
+}
+async function v(i, e = Date.now()) {
+  try {
+    return (await fetch(i.checkinUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoint: i.endpoint })
+    })).ok ? (await O({
+      ...i,
+      lastCheckinAt: new Date(e).toISOString()
+    }), !0) : !1;
+  } catch {
+    return !1;
+  }
+}
+async function B(i = Date.now()) {
+  const e = await U();
+  return !e || K(e, i) ? !1 : v(e, i);
+}
+class M {
+  listeners = /* @__PURE__ */ new Map();
+  on(e, t) {
+    this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(t);
+  }
+  off(e, t) {
+    const r = this.listeners.get(e);
+    r && r.delete(t);
+  }
+  emit(e, t) {
+    const r = this.listeners.get(e);
+    r && r.forEach((n) => n(t));
+  }
+  removeAllListeners(e) {
+    e ? this.listeners.delete(e) : this.listeners.clear();
+  }
+}
+async function L() {
+  const i = await crypto.subtle.generateKey(
+    {
+      name: "ECDSA",
+      namedCurve: "P-256"
+    },
+    !0,
+    ["sign", "verify"]
+  ), e = await crypto.subtle.exportKey("raw", i.publicKey), t = A(e), r = await crypto.subtle.exportKey("jwk", i.privateKey);
+  if (!r.d)
+    throw new Error("Failed to export private key");
+  return {
+    publicKey: t,
+    privateKey: r.d
+  };
+}
+function x(i) {
+  return i === void 0 ? !0 : i === 408 || i === 425 || i === 429 || i >= 500;
+}
+const l = {
+  maxAttempts: 3,
+  delayMs: 1e3,
+  backoffMultiplier: 2,
+  shouldRetry: x
+};
+class W extends M {
+  config;
+  retryConfig;
+  checkinTimer = null;
   constructor(e) {
-    console.debug("PushClient initialized"), this.config = e;
+    super(), console.debug("PushClient initialized"), this.config = e;
+    const t = e.retry?.maxAttempts ?? l.maxAttempts, r = e.retry?.delayMs ?? l.delayMs, n = e.retry?.backoffMultiplier ?? l.backoffMultiplier;
+    this.retryConfig = {
+      maxAttempts: t < 1 ? 1 : t,
+      delayMs: r < 1 ? 1 : r,
+      backoffMultiplier: n < 1 ? 1 : n,
+      shouldRetry: e.retry?.shouldRetry ?? l.shouldRetry
+    };
+  }
+  on(e, t) {
+    super.on(e, t);
+  }
+  off(e, t) {
+    super.off(e, t);
   }
-  /**
-   * Checks if the client is already subscribed to push notifications.
-   * @returns A promise that resolves to true if subscribed, false otherwise.
-   */
   async isSubscribed() {
     if (!this.isSupported())
       return !1;
     const e = await navigator.serviceWorker.getRegistration();
     return e ? !!await e.pushManager.getSubscription() : !1;
   }
-  /**
-   * Registers the client for push notifications.
-   * Checks support, config, and existing subscription.
-   * Requests permission and registers with backend if necessary.
-   * @returns A promise that resolves to true if registration is successful (or already exists), false otherwise.
-   */
-  async register() {
-    console.debug("Registering push notifications...");
+  getPermissionState() {
+    return this.isSupported() ? Notification.permission : "unsupported";
+  }
+  async register(e = {}) {
     try {
       if (!this.isSupported())
-        return console.warn("Push notifications are not supported in this browser."), !1;
+        throw new p();
       if (!this.validateConfig())
-        return console.error("Invalid PushClient configuration."), !1;
-      const e = await this.registerServiceWorker();
-      if (await e.pushManager.getSubscription())
-        return !0;
-      const r = await Notification.requestPermission();
-      if (console.debug(`Notification permission: ${r}`), r !== "granted")
-        return console.warn("Notification permission denied."), !1;
-      const s = o(
-        this.config.vapidPublicKey
-      ), t = await e.pushManager.subscribe({
+        throw new o(
+          y.NOT_SUPPORTED,
+          "Invalid PushClient configuration"
+        );
+      if (!N(this.config.vapidPublicKey))
+        throw new u("Invalid VAPID key format");
+      this.assertCheckinConfigured();
+      const t = await this.registerServiceWorker(), r = await t.pushManager.getSubscription();
+      if (r)
+        return e.force && await this.sendToBackendWithRetry(r), await this.persistCheckinConfig(r), !0;
+      const n = this.getPermissionState();
+      if (n === "denied")
+        throw new f();
+      if (n === "default") {
+        const c = await Notification.requestPermission();
+        if (console.debug(`Notification permission: ${c}`), c !== "granted")
+          throw new f();
+        this.emit("permissionChange", { permission: "granted" });
+      }
+      const s = I(this.config.vapidPublicKey), a = await t.pushManager.subscribe({
         userVisibleOnly: !0,
         applicationServerKey: s
       });
-      return await this.sendToBackend(t), !0;
+      return await this.sendToBackendWithRetry(a), await this.persistCheckinConfig(a), this.emit("subscriptionChange", { subscribed: !0 }), !0;
+    } catch (t) {
+      throw t instanceof o ? t : (console.error("Failed to register push client:", t), new u(
+        t instanceof Error ? t.message : "Unknown error"
+      ));
+    }
+  }
+  async unsubscribe(e = {}) {
+    console.debug("Unsubscribing from push notifications...");
+    try {
+      if (!this.isSupported())
+        return !1;
+      const t = await navigator.serviceWorker.getRegistration();
+      if (!t)
+        return !1;
+      const r = await t.pushManager.getSubscription();
+      if (!r)
+        return !1;
+      if (!await r.unsubscribe())
+        throw new u("Failed to unsubscribe from push manager");
+      return this.stopPeriodicCheckin(), await _(), this.getUnregisterUrl() && e.notifyBackend !== !1 && await this.sendUnregisterToBackendWithRetry(r), this.emit("subscriptionChange", { subscribed: !1 }), !0;
+    } catch (t) {
+      throw t instanceof o ? t : (console.error("Failed to unsubscribe:", t), new u(
+        t instanceof Error ? t.message : "Unknown error during unsubscription"
+      ));
+    }
+  }
+  async updateSubscription() {
+    console.debug("Updating push subscription...");
+    try {
+      if (!this.isSupported())
+        throw new p();
+      if (!this.validateConfig())
+        throw new o(
+          y.NOT_SUPPORTED,
+          "Invalid PushClient configuration"
+        );
+      const e = await navigator.serviceWorker.getRegistration();
+      if (!e)
+        throw new u("No service worker registration found");
+      const t = await e.pushManager.getSubscription();
+      if (!t)
+        return console.debug("No existing subscription, creating new one"), await this.register();
+      const r = I(this.config.vapidPublicKey);
+      await t.unsubscribe();
+      const n = await e.pushManager.subscribe({
+        userVisibleOnly: !0,
+        applicationServerKey: r
+      });
+      return await this.sendToBackendWithRetry(n), await this.persistCheckinConfig(n), this.emit("subscriptionChange", { subscribed: !0 }), !0;
     } catch (e) {
-      return console.error("Failed to register push client:", e), !1;
+      throw e instanceof o ? e : (console.error("Failed to update subscription:", e), new u(
+        e instanceof Error ? e.message : "Unknown error during subscription update"
+      ));
     }
   }
   /**
-   * Checks if push notifications are supported in the browser.
-   * @returns True if supported, false otherwise.
+   * Whether this browser supports Web Push (service worker, PushManager and
+   * Notification). Same result as {@link isPushSupported}, which needs no client.
    */
   isSupported() {
-    return typeof window < "u" && "serviceWorker" in navigator && !!navigator.serviceWorker && "PushManager" in window && "Notification" in window;
+    return R();
+  }
+  validateConfig() {
+    return this.config.endpoints?.register ? !!this.config.vapidPublicKey : !!this.config.vapidPublicKey && !!this.config.backendRegisterUrl;
+  }
+  getRegisterUrl() {
+    return this.config.endpoints?.register ? this.config.endpoints.register : this.config.backendRegisterUrl || "/api/register";
+  }
+  getUnregisterUrl() {
+    if (this.config.endpoints?.unregister)
+      return this.config.endpoints.unregister;
+    if (this.config.backendUnregisterUrl)
+      return this.config.backendUnregisterUrl;
+    const e = this.getRegisterUrl();
+    return e.endsWith("/register") ? e.slice(0, -9) + "/unregister" : null;
   }
   /**
-   * Validates the configuration.
-   * @returns True if valid, false otherwise.
+   * Requires an explicit `backendCheckinUrl`; throws {@link CheckinConfigError}
+   * instead of silently skipping check-ins, so a misconfigured integration
+   * fails loudly before any subscription is created or reused.
+   *
+   * @throws {CheckinConfigError} When `backendCheckinUrl` is not configured.
    */
-  validateConfig() {
-    return !!(this.config.vapidPublicKey && this.config.backendRegisterUrl);
+  assertCheckinConfigured() {
+    if (!this.config.backendCheckinUrl)
+      throw new d(
+        "backendCheckinUrl is required: set it to your backend check-in relay URL so push receipts and periodic pings can record subscriber liveness. Without it, activity analytics decay to registration-time check-ins only."
+      );
   }
   /**
-   * Registers the service worker.
-   * @returns A promise that resolves with the ServiceWorkerRegistration.
+   * Cache the check-in configuration for the service worker so received
+   * pushes can report liveness.
+   *
+   * @param subscription - The push subscription being registered.
+   * @throws {CheckinConfigError} When `backendCheckinUrl` is not configured.
    */
+  async persistCheckinConfig(e) {
+    this.assertCheckinConfigured(), await O({
+      checkinUrl: this.config.backendCheckinUrl,
+      endpoint: e.endpoint
+    });
+  }
+  /**
+   * Opt-in periodic check-in: reports liveness immediately and then every
+   * `intervalMs` while the page stays open, in addition to the automatic
+   * push-driven check-ins. Intended for quota-accurate monthly actives.
+   *
+   * @param intervalMs - Check-in interval in milliseconds (default 6h).
+   * @throws {CheckinConfigError} When `backendCheckinUrl` is not configured —
+   *   periodic check-ins would silently do nothing, which must fail loudly.
+   */
+  startPeriodicCheckin(e = 360 * 60 * 1e3) {
+    if (!this.config.backendCheckinUrl)
+      throw new d(
+        "startPeriodicCheckin() requires backendCheckinUrl to be configured: set it to your backend check-in relay URL so periodic pings can record subscriber liveness."
+      );
+    this.stopPeriodicCheckin();
+    const t = async () => {
+      const r = await U();
+      r && await v(r);
+    };
+    t(), this.checkinTimer = setInterval(() => {
+      t();
+    }, e);
+  }
+  /** Stop the periodic check-in started by startPeriodicCheckin. */
+  stopPeriodicCheckin() {
+    this.checkinTimer !== null && (clearInterval(this.checkinTimer), this.checkinTimer = null);
+  }
+  async getHeaders() {
+    const e = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.headers)
+      return { ...e, ...this.config.headers };
+    if (this.config.getHeaders) {
+      const t = await this.config.getHeaders();
+      return { ...e, ...t };
+    }
+    return e;
+  }
   async registerServiceWorker() {
     const e = this.config.serviceWorkerPath || "/sw.js";
-    console.debug(`[PushClient] Registering service worker at: ${e}`);
     try {
-      const i = await navigator.serviceWorker.register(e, {
-        scope: "/"
+      const t = await navigator.serviceWorker.register(e, {
+        scope: "/",
+        type: "module"
       });
-      console.debug("[PushClient] Service Worker registered:", i), console.debug(
-        `[PushClient] SW state: ${i.installing ? "installing" : i.waiting ? "waiting" : i.active ? "active" : "unknown"}`
-      );
+      console.debug("[PushClient] Service Worker registered:", t);
       const r = await navigator.serviceWorker.ready;
       return console.debug("[PushClient] Service Worker ready"), r;
-    } catch (i) {
-      throw console.error("[PushClient] Failed to register service worker:", i), i;
+    } catch (t) {
+      throw console.error("[PushClient] Failed to register service worker:", t), new u(
+        `Failed to register service worker: ${t instanceof Error ? t.message : "Unknown error"}`
+      );
     }
   }
-  /**
-   * Sends the subscription to the backend.
-   * @param subscription - The push subscription object.
-   * @returns A promise that resolves when the subscription is sent.
-   * @throws Will throw an error if the backend request fails.
-   */
-  async sendToBackend(e) {
-    console.debug("[PushClient] Sending subscription to backend", e);
-    const i = {
+  async sleep(e) {
+    return new Promise((t) => setTimeout(t, e));
+  }
+  backoffDelay(e) {
+    return this.retryConfig.delayMs * Math.pow(this.retryConfig.backoffMultiplier, e - 1);
+  }
+  async sendToBackendWithRetry(e) {
+    const t = this.getRegisterUrl(), r = await this.getHeaders(), n = {
       ...e.toJSON(),
       tags: this.config.tags
-    }, r = await fetch(this.config.backendRegisterUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(i)
-    });
-    if (!r.ok)
-      throw new Error(
-        `Failed to register push subscription: ${r.statusText}`
-      );
+    };
+    for (let s = 1; s <= this.retryConfig.maxAttempts; s++) {
+      console.debug(`[PushClient] Sending subscription to backend (attempt ${s})`, e);
+      let a, c, m;
+      try {
+        const h = await fetch(t, {
+          method: "POST",
+          headers: r,
+          body: JSON.stringify(n)
+        });
+        if (h.ok)
+          return;
+        a = h.status, c = h.statusText || `HTTP ${h.status}`;
+      } catch (h) {
+        c = h instanceof Error ? h.message : "Unknown error", m = h;
+      }
+      if (s === this.retryConfig.maxAttempts || !this.retryConfig.shouldRetry(a))
+        throw new b(
+          `Failed to register push subscription after ${s} attempt${s === 1 ? "" : "s"}: ${c}`,
+          { status: a, cause: m }
+        );
+      const S = this.backoffDelay(s);
+      console.debug(`[PushClient] Backend registration failed, retrying in ${S}ms`), await this.sleep(S);
+    }
+  }
+  async sendUnregisterToBackendWithRetry(e) {
+    const t = this.getUnregisterUrl();
+    if (!t)
+      return;
+    const r = await this.getHeaders(), n = {
+      ...e.toJSON(),
+      action: "unsubscribe"
+    };
+    for (let s = 1; s <= this.retryConfig.maxAttempts; s++) {
+      console.debug(`[PushClient] Sending unregistration to backend (attempt ${s})`);
+      let a;
+      try {
+        const c = await fetch(t, {
+          method: "POST",
+          headers: r,
+          body: JSON.stringify(n)
+        });
+        if (c.ok)
+          return;
+        a = c.status;
+      } catch {
+        a = void 0;
+      }
+      if (s === this.retryConfig.maxAttempts || !this.retryConfig.shouldRetry(a)) {
+        console.warn("[PushClient] Failed to notify backend of unsubscription, but local unsubscribe succeeded");
+        return;
+      }
+      await this.sleep(this.backoffDelay(s));
+    }
   }
 }
 export {
-  c as PushClient,
-  a as arrayBufferToUrlBase64,
-  o as urlBase64ToUint8Array
+  b as BackendRegistrationError,
+  w as CHECKIN_CACHE_NAME,
+  k as CHECKIN_CONFIG_URL,
+  D as CHECKIN_THROTTLE_MS,
+  d as CheckinConfigError,
+  p as NotSupportedError,
+  f as PermissionDeniedError,
+  W as PushClient,
+  o as PushClientError,
+  y as PushClientErrorCode,
+  M as PushClientEventEmitter,
+  u as SubscriptionError,
+  P as UnsubscriptionError,
+  g as ValidationError,
+  A as arrayBufferToUrlBase64,
+  _ as clearCheckinConfig,
+  x as defaultShouldRetry,
+  L as generateVapidKeys,
+  C as isCacheStorageAvailable,
+  K as isCheckinThrottled,
+  R as isPushSupported,
+  N as isValidVapidKey,
+  B as maybeCheckin,
+  v as performCheckin,
+  U as readCheckinConfig,
+  I as urlBase64ToUint8Array,
+  F as validateVapidKey,
+  O as writeCheckinConfig
 };