@arsel.sa/web-sdk 1.0.0

package/dist/arsel.js

@@ -0,0 +1,600 @@
+const G = "arsel";
+const w = "events";
+let I = null;
+function Q() {
+  return I || (I = new Promise((e, t) => {
+    const n = indexedDB.open(G, 1);
+    n.onupgradeneeded = () => {
+      const i = n.result;
+      i.objectStoreNames.contains("kv") || i.createObjectStore("kv"), i.objectStoreNames.contains(w) || i.createObjectStore(w, { keyPath: "id", autoIncrement: !0 });
+    }, n.onsuccess = () => e(n.result), n.onerror = () => t(n.error);
+  }), I);
+}
+function y(e, t, n) {
+  return Q().then(
+    (i) => new Promise((s, a) => {
+      const o = n(i.transaction(e, t).objectStore(e));
+      o.onsuccess = () => s(o.result), o.onerror = () => a(o.error);
+    })
+  );
+}
+function c(e) {
+  return y("kv", "readonly", (t) => t.get(e)).then(
+    (t) => t ?? null
+  );
+}
+function u(e, t) {
+  return y("kv", "readwrite", (n) => n.put(t, e));
+}
+function A(e) {
+  return y("kv", "readwrite", (t) => t.delete(e));
+}
+function ee(e, t) {
+  return y(
+    w,
+    "readwrite",
+    (n) => n.add({ body: e, idempotencyKey: t, createdAtMs: Date.now() })
+  );
+}
+function te() {
+  return y(w, "readonly", (e) => e.getAll());
+}
+function ne(e) {
+  return y(w, "readwrite", (t) => t.delete(e));
+}
+function re() {
+  return y(w, "readonly", (e) => e.count());
+}
+const r = {
+  clientKey: "client_key",
+  baseUrl: "base_url",
+  anonymousId: "anonymous_id",
+  externalId: "external_id",
+  email: "email",
+  phoneNumber: "phone_number",
+  installationId: "installation_id",
+  deviceSecret: "device_secret",
+  vapidKeyVersion: "vapid_key_version",
+  endpoint: "endpoint",
+  sessionStartedAt: "session_started_at",
+  backgroundedAt: "backgrounded_at",
+  lastResponseCode: "last_response_code",
+  lastResponsePath: "last_response_path",
+  lastResponseAtMs: "last_response_at"
+};
+async function T() {
+  const e = await c(r.anonymousId);
+  if (e) return e;
+  const t = crypto.randomUUID();
+  return await u(r.anonymousId, t), t;
+}
+async function ie() {
+  const e = crypto.randomUUID();
+  return await u(r.anonymousId, e), e;
+}
+const K = "1.0.0", W = { "X-Arsel-SDK": `web/${K}` }, f = {
+  success: "success",
+  retryable: "retryable",
+  permanent: "permanent",
+  reauth: "reauth"
+}, O = -1;
+function se(e, t) {
+  return e >= 200 && e <= 299 ? f.success : e === 408 || e === 429 || e >= 500 && e <= 599 ? f.retryable : t && (e === 401 || e === 403 || e === 404) ? f.reauth : e === 404 ? f.retryable : f.permanent;
+}
+async function N(e, t) {
+  try {
+    await Promise.all([
+      u(r.lastResponseCode, t),
+      u(r.lastResponsePath, e),
+      u(r.lastResponseAtMs, Date.now())
+    ]);
+  } catch {
+  }
+}
+async function R(e, t, n, i = {}, s = !1) {
+  let a;
+  try {
+    a = await fetch(e + t, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...W, ...i },
+      body: JSON.stringify(n),
+      // The SDK never relies on cookies, and sending them would attach a
+      // first-party session to a cross-origin call for no reason.
+      credentials: "omit",
+      keepalive: !0
+    });
+  } catch {
+    return await N(t, O), { result: f.retryable, code: O, body: null };
+  }
+  await N(t, a.status);
+  const o = se(a.status, s);
+  let l = null;
+  try {
+    l = await a.json();
+  } catch {
+  }
+  return { result: o, code: a.status, body: l };
+}
+async function B(e, t) {
+  try {
+    const n = await fetch(e + t, {
+      credentials: "omit",
+      headers: W
+    });
+    return await N(t, n.status), n.ok ? await n.json() : null;
+  } catch {
+    return await N(t, O), null;
+  }
+}
+const ae = "/v1/events/send", v = "arsel.", oe = `${v}session_start`, ce = `${v}session_end`, le = `${v}identify`, ue = 80, de = 128, fe = 255, U = 50, pe = 8, V = 64 * 1024;
+function D(e, t) {
+  if (e === null) return null;
+  const n = typeof e;
+  if (n === "string" || n === "boolean") return e;
+  if (n === "number") return Number.isFinite(e) ? e : String(e);
+  if (n === "bigint") return String(e);
+  if (e instanceof Date)
+    return Number.isNaN(e.getTime()) ? void 0 : e.toISOString();
+  if (n !== "object" || t >= pe) return;
+  if (Array.isArray(e))
+    return e.map((s) => D(s, t + 1) ?? null);
+  const i = {};
+  for (const [s, a] of Object.entries(e)) {
+    if (!s) continue;
+    const o = D(a, t + 1);
+    o !== void 0 && (i[s] = o);
+  }
+  return i;
+}
+function ye(e) {
+  const t = {};
+  let n = 2, i = !1;
+  for (const [s, a] of Object.entries(e ?? {})) {
+    if (!s) continue;
+    const o = D(a, 0);
+    if (o === void 0) continue;
+    const l = s.length + JSON.stringify(o).length + 6;
+    if (n + l > V) {
+      i = !0;
+      continue;
+    }
+    n += l, t[s] = o;
+  }
+  return i && console.warn(
+    `[arsel] event data exceeded ${V} serialized bytes — oversized properties were dropped`
+  ), t;
+}
+async function we(e, t, n) {
+  const [i, s, a, o] = await Promise.all([
+    T(),
+    c(r.externalId),
+    c(r.email),
+    c(r.phoneNumber)
+  ]), l = {
+    event: e.slice(0, ue),
+    // Always sent, even once identified: it is what the backend merges FROM.
+    anonymous_id: i.slice(0, de),
+    data: ye(t),
+    timestamp: new Date(n).toISOString()
+  };
+  return s && (l.external_id = s.slice(0, fe)), a && (l.email = a), o && (l.phone_number = o), JSON.stringify(l);
+}
+async function g(e, t, n = Date.now()) {
+  await ee(await we(e, t, n), crypto.randomUUID()), S().catch(() => {
+  });
+}
+let h = null;
+function S() {
+  return h || (h = he().finally(() => {
+    h = null;
+  }), h);
+}
+function me(e) {
+  const t = e[0].idempotencyKey;
+  return e.length === 1 ? t : `${t}:${e[e.length - 1].idempotencyKey}:${e.length}`;
+}
+function be(e, t, n) {
+  e.some(
+    (s) => s.external_id || s.email || s.phone_number
+  ) && console.error(
+    `[arsel] ${e.length} event(s) carrying identifiers were rejected permanently (HTTP ${t}) and dropped. Response: ${JSON.stringify(n)}`
+  );
+}
+async function he() {
+  const [e, t] = await Promise.all([
+    c(r.clientKey),
+    c(r.baseUrl)
+  ]);
+  if (!(!e || !t))
+    for (; ; ) {
+      const n = await te();
+      if (n.length === 0) return;
+      for (let i = 0; i < n.length; i += U) {
+        const s = n.slice(i, i + U), a = s.map(
+          (l) => JSON.parse(l.body)
+        ), o = await R(
+          t,
+          ae,
+          s.length === 1 ? a[0] : { events: a },
+          {
+            Authorization: `Bearer ${e}`,
+            "Idempotency-Key": me(s)
+          }
+        );
+        if (o.result === f.retryable) return;
+        o.result !== f.success && be(a, o.code, o.body);
+        for (const l of s)
+          l.id !== void 0 && await ne(l.id);
+      }
+    }
+}
+function C(e) {
+  const t = e.replace(/-/g, "+").replace(/_/g, "/"), n = atob(t + "=".repeat((4 - t.length % 4) % 4)), i = new Uint8Array(n.length);
+  for (let s = 0; s < n.length; s += 1) i[s] = n.charCodeAt(s);
+  return i.buffer;
+}
+function b() {
+  return typeof navigator < "u" && "serviceWorker" in navigator && typeof PushManager < "u" && typeof Notification < "u";
+}
+function F(e) {
+  return `/api/v1/orgs/${e}/push/web/config`;
+}
+function X(e) {
+  return `/api/v1/orgs/${e}/push/subscriptions`;
+}
+const H = 1e4;
+let m = "none", E = null, k = null;
+function ve() {
+  m = "external";
+}
+async function ge(e) {
+  if (b()) {
+    m = "managed";
+    try {
+      E = await navigator.serviceWorker.register(e), k = null;
+    } catch (t) {
+      E = null, k = `service worker registration failed for '${e}': ${String(t)}. Check that the file is deployed and served with a JavaScript content type.`;
+    }
+  }
+}
+function Se(e, t) {
+  return e.active ? Promise.resolve(e) : new Promise((n, i) => {
+    const s = setTimeout(() => {
+      i(
+        new Error(
+          `service worker did not activate within ${t}ms — check the worker script for load errors in DevTools → Application → Service Workers`
+        )
+      );
+    }, t), a = (l) => {
+      l.addEventListener("statechange", () => {
+        l.state === "activated" ? (clearTimeout(s), n(e)) : l.state === "redundant" && (clearTimeout(s), i(
+          new Error(
+            "service worker became redundant before activating — its script likely failed to parse"
+          )
+        ));
+      });
+    }, o = e.installing ?? e.waiting;
+    o ? a(o) : e.addEventListener("updatefound", () => {
+      e.installing && a(e.installing);
+    });
+  });
+}
+function Ee(e, t, n) {
+  return Promise.race([
+    e,
+    new Promise((i, s) => {
+      setTimeout(() => s(new Error(n)), t);
+    })
+  ]);
+}
+async function $(e = H) {
+  if (m === "none")
+    throw new Error(
+      "push is not configured — pass serviceWorkerPath to init(), or serviceWorker: 'external' if your own service worker imports arsel-sw.js"
+    );
+  if (m === "external")
+    return Ee(
+      navigator.serviceWorker.ready,
+      e,
+      `no service worker became active within ${e}ms — with serviceWorker: 'external', your own worker must be registered and must importScripts arsel-sw.js`
+    );
+  if (k) throw new Error(k);
+  if (!E)
+    throw new Error("service worker registration has not completed");
+  return Se(E, e);
+}
+async function _e(e = H) {
+  try {
+    return await $(e), null;
+  } catch (t) {
+    return t instanceof Error ? t.message : String(t);
+  }
+}
+async function Ie() {
+  const [e, t] = await Promise.all([
+    c(r.clientKey),
+    c(r.baseUrl)
+  ]);
+  if (!e || !t || !b()) return !1;
+  const n = await B(t, F(e));
+  if (!(n != null && n.vapidPublicKey)) return !1;
+  let i;
+  try {
+    i = await $();
+  } catch (a) {
+    return console.error(`[arsel] ${a instanceof Error ? a.message : a}`), !1;
+  }
+  const s = await i.pushManager.subscribe({
+    // Non-negotiable: the Push API only accepts a userVisibleOnly subscription
+    // in Chrome, and silent push is what the restriction exists to prevent.
+    userVisibleOnly: !0,
+    applicationServerKey: C(n.vapidPublicKey)
+  });
+  return L(s, n.keyVersion);
+}
+async function L(e, t) {
+  var _;
+  const [n, i, s] = await Promise.all([
+    c(r.clientKey),
+    c(r.baseUrl),
+    T()
+  ]);
+  if (!n || !i) return !1;
+  let a = await c(r.installationId);
+  a || (a = crypto.randomUUID(), await u(r.installationId, a));
+  const o = e.toJSON(), l = await R(
+    i,
+    X(n),
+    {
+      installationId: a,
+      platform: "web",
+      endpoint: o.endpoint,
+      keys: o.keys,
+      // The same id the events API sends — it is what binds this subscription
+      // to the contact the browser's events resolve to.
+      anonymousId: s,
+      enablementStatus: Notification.permission === "granted" ? "AUTHORIZED" : "DENIED",
+      deviceTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      deviceLocale: navigator.language
+    }
+  );
+  return l.result !== f.success ? !1 : ((_ = l.body) != null && _.deviceSecret && await u(r.deviceSecret, l.body.deviceSecret), await u(r.vapidKeyVersion, t), await u(r.endpoint, o.endpoint ?? null), !0);
+}
+async function Ae() {
+  const [e, t, n, i] = await Promise.all([
+    c(r.clientKey),
+    c(r.baseUrl),
+    c(r.installationId),
+    c(r.deviceSecret)
+  ]);
+  return !e || !t || !n || !i ? !1 : (await R(
+    t,
+    `${X(e)}/unsubscribe`,
+    { installationId: n },
+    { "X-Arsel-Device-Auth": i },
+    !0
+  )).result === f.success;
+}
+async function Ne() {
+  if (m === "none" || !b() || Notification.permission !== "granted") return;
+  const [e, t] = await Promise.all([
+    c(r.clientKey),
+    c(r.baseUrl)
+  ]);
+  if (!e || !t) return;
+  const n = await B(t, F(e));
+  if (!(n != null && n.vapidPublicKey)) return;
+  let i;
+  try {
+    i = await $();
+  } catch {
+    return;
+  }
+  const s = await i.pushManager.getSubscription(), a = await c(r.vapidKeyVersion);
+  if (s && a === n.keyVersion) return;
+  s && await s.unsubscribe().catch(() => !1);
+  const o = await i.pushManager.subscribe({
+    userVisibleOnly: !0,
+    applicationServerKey: C(n.vapidPublicKey)
+  });
+  await L(o, n.keyVersion);
+}
+async function ke() {
+  if (!b()) return !1;
+  try {
+    const e = m === "managed" ? E : await navigator.serviceWorker.getRegistration();
+    return e ? await e.pushManager.getSubscription() !== null : !1;
+  } catch {
+    return !1;
+  }
+}
+const Pe = 30 * 6e4;
+async function z(e = Date.now()) {
+  const t = await c(r.sessionStartedAt) ?? 0, n = await c(r.backgroundedAt) ?? 0;
+  if (t !== 0) {
+    if (n === 0 || e - n < Pe) return;
+    await g(
+      ce,
+      { duration_seconds: Math.round((n - t) / 1e3) },
+      n
+    );
+  }
+  await u(r.sessionStartedAt, e), await u(r.backgroundedAt, 0), await g(oe, {}, e);
+}
+async function x(e = Date.now()) {
+  (await c(r.sessionStartedAt) ?? 0) !== 0 && await u(r.backgroundedAt, e);
+}
+function Te() {
+  typeof document > "u" || (document.addEventListener("visibilitychange", () => {
+    document.visibilityState === "visible" ? z() : x();
+  }), window.addEventListener("pagehide", () => void x()));
+}
+let d = null, J = !1;
+function p(e) {
+  J && console.info(`[arsel] ${e}`);
+}
+const Ke = /^\+[1-9]\d{6,14}$/, Oe = /^[^\s@]+@[^\s@]+\.[^\s@]+$/, M = 100;
+let P = [], j = !1;
+function De() {
+  typeof window < "u" && window.addEventListener("online", () => void S().catch(() => {
+  })), typeof document < "u" && document.addEventListener("visibilitychange", () => {
+    document.visibilityState === "visible" && S().catch(() => {
+    });
+  });
+}
+function Re(e) {
+  return d || (d = (async () => {
+    var a;
+    if (!e.clientKey) throw new Error("Arsel: clientKey is required");
+    const t = /^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(
+      e.baseUrl ?? ""
+    );
+    if (!((a = e.baseUrl) != null && a.startsWith("https://")) && !t)
+      throw new Error("Arsel: baseUrl must be HTTPS (http is allowed for localhost only)");
+    J = e.debug ?? !1;
+    const n = e.baseUrl.replace(/\/+$/, "");
+    await Promise.all([
+      u(r.clientKey, e.clientKey),
+      u(r.baseUrl, n)
+    ]), await T();
+    const i = P;
+    P = [];
+    for (const o of i)
+      await g(o.name, o.properties, o.timestampMs);
+    e.serviceWorker === "external" ? ve() : e.serviceWorkerPath && await ge(e.serviceWorkerPath), Te(), De();
+    const s = typeof document < "u" ? document : void 0;
+    (s == null ? void 0 : s.visibilityState) === "visible" && s.prerendering !== !0 && await z(), S(), Ne(), p(`initialized (sdk ${K})`);
+  })(), d);
+}
+async function $e(e, t = {}) {
+  const n = e == null ? void 0 : e.trim();
+  if (!n) {
+    p("track() called with a blank event name — ignoring");
+    return;
+  }
+  if (n.startsWith(v)) {
+    p(`'${v}' is reserved for the SDK — ignoring '${n}'`);
+    return;
+  }
+  if (!d) {
+    if (P.length >= M) {
+      j || (j = !0, console.warn(
+        `[arsel] more than ${M} events tracked before init() — dropping the rest. Call init() earlier.`
+      ));
+      return;
+    }
+    P.push({ name: n, properties: t, timestampMs: Date.now() });
+    return;
+  }
+  await d, await g(n, t);
+}
+async function Ue(e) {
+  await d;
+  let { email: t, phoneNumber: n } = e ?? {};
+  const i = e == null ? void 0 : e.externalId;
+  if (t && !Oe.test(t) && (console.error(`[arsel] identify(): '${t}' is not a valid email address — ignored`), t = void 0), n && !Ke.test(n) && (console.error(
+    `[arsel] identify(): '${n}' is not E.164 (e.g. +966501234567) — ignored`
+  ), n = void 0), !i && !t && !n) {
+    p("identify() needs at least one of externalId, email or phoneNumber");
+    return;
+  }
+  i && await u(r.externalId, i), t && await u(r.email, t), n && await u(r.phoneNumber, n), await g(le, {});
+}
+async function Ve() {
+  await d, await Promise.all([
+    A(r.externalId),
+    A(r.email),
+    A(r.phoneNumber),
+    A(r.sessionStartedAt)
+  ]), await ie(), p("identity reset");
+}
+async function xe() {
+  await d;
+  const e = await Ae();
+  return p(e ? "push opt-out recorded" : "push opt-out not sent — no registration to revoke"), e;
+}
+async function Me() {
+  if (await d, !b()) return !1;
+  const e = await _e();
+  if (e)
+    return console.error(`[arsel] promptForPush(): ${e}`), !1;
+  const t = await Notification.requestPermission();
+  return t !== "granted" ? (p(`notification permission: ${t}`), !1) : Ie();
+}
+async function je() {
+  return await d, T();
+}
+async function We() {
+  const [
+    e,
+    t,
+    n,
+    i,
+    s,
+    a,
+    o,
+    l,
+    _,
+    q,
+    Y,
+    Z
+  ] = await Promise.all([
+    c(r.anonymousId),
+    c(r.externalId),
+    c(r.email),
+    c(r.phoneNumber),
+    c(r.installationId),
+    c(r.deviceSecret),
+    c(r.vapidKeyVersion),
+    re(),
+    ke(),
+    c(r.lastResponseCode),
+    c(r.lastResponsePath),
+    c(r.lastResponseAtMs)
+  ]);
+  return {
+    sdkVersion: K,
+    initialized: d !== null,
+    anonymousId: e,
+    hasAssertedIdentity: !!(t || n || i),
+    installationId: s,
+    hasDeviceSecret: !!a,
+    pendingEvents: l,
+    permission: b() ? Notification.permission : "unsupported",
+    isSubscribed: _,
+    vapidKeyVersion: o,
+    lastResponseCode: q,
+    lastResponsePath: Y,
+    lastResponseAtMs: Z
+  };
+}
+async function Be() {
+  await d, await S();
+}
+const Ce = {
+  init: Re,
+  track: $e,
+  identify: Ue,
+  reset: Ve,
+  optOut: xe,
+  promptForPush: Me,
+  getAnonymousId: je,
+  diagnostics: We,
+  flushNow: Be,
+  SDK_VERSION: K
+};
+export {
+  Ce as Arsel,
+  K as SDK_VERSION,
+  Ce as default,
+  We as diagnostics,
+  Be as flushNow,
+  je as getAnonymousId,
+  Ue as identify,
+  Re as init,
+  xe as optOut,
+  Me as promptForPush,
+  Ve as reset,
+  $e as track
+};
+//# sourceMappingURL=arsel.js.map