@braze/web-sdk 6.3.1 → 6.5.0

package/src/DUST/dust-shared-worker-impl.js

@@ -0,0 +1,240 @@
+const ne = self;
+let oe = null,
+  te = null,
+  le = 0,
+  ce = null,
+  ae = !1;
+const re = new Map();
+let ie = null,
+  se = null,
+  ue = null,
+  me = null,
+  de = null;
+const pe = { mn: null, Se: null };
+function fe(e) {
+  re.forEach((n, o) => {
+    try {
+      n.port.postMessage(e);
+    } catch (e) {
+      re.delete(o);
+    }
+  });
+}
+function Te() {
+  if (me && re.has(me)) return;
+  const e = re.keys().next().value;
+  (me = e || null),
+    me && console.log("[Braze Real-Time] Elected leader port:", me);
+}
+function Re(e) {
+  if ((Te(), !me))
+    return void console.warn("[Braze Real-Time] No leader to send message to");
+  const n = re.get(me);
+  if (n)
+    try {
+      n.port.postMessage(e);
+    } catch (n) {
+      re.delete(me), (me = null), Re(e);
+    }
+}
+function ge() {
+  (ae = !1),
+    null !== ce && (clearTimeout(ce), (ce = null)),
+    null !== ue && (clearTimeout(ue), (ue = null)),
+    null !== de && (clearTimeout(de), (de = null)),
+    oe && (oe.close(), (oe = null), fe({ type: "disconnected" }));
+}
+function he() {
+  if (!te) return;
+  le++;
+  const { an: e, ln: n, cn: o } = te.hn;
+  let t = ie;
+  (null == t || t < e) && (t = e);
+  const l = Math.min(
+    n,
+    ((c = e), (a = t * o), Math.floor(Math.random() * (a - c + 1)) + c),
+  );
+  var c, a;
+  (ie = l),
+    console.log(
+      "[Braze Real-Time] Retrying in " + l + "ms (attempt " + le + "/5)",
+    ),
+    (ce = setTimeout(function () {
+      (ce = null), pe.mn();
+    }, l));
+}
+function ze(e) {
+  if (!te) return;
+  if (oe && !e)
+    return void console.warn("[Braze Real-Time] Connection already exists");
+  if (ae && !e)
+    return void console.warn(
+      "[Braze Real-Time] Connection attempt already in progress",
+    );
+  ae = !0;
+  const { ki: n, mite: o, auth: t } = te,
+    l = /^https?:\/\//i.test(n) ? n : "https://" + n;
+  let c = "mite=" + encodeURIComponent(o) + "&attempts=" + le;
+  t && (c += "&auth=" + encodeURIComponent(t)),
+    se && (c += "&rcs=" + encodeURIComponent(se));
+  const a = l + "/sse?" + c;
+  try {
+    const n = new EventSource(a);
+    (n.onopen = function () {
+      e
+        ? (console.log(
+            "[Braze Real-Time] Gapless reconnection: new connection established, closing old connection",
+          ),
+          e.close())
+        : console.log("[Braze Real-Time] Connection established"),
+        (oe = n),
+        (ae = !1),
+        (le = 0),
+        (ie = null),
+        fe({ type: "connected" });
+    }),
+      n.addEventListener("msg", function (e) {
+        pe.Se(e.data);
+      }),
+      (n.onerror = function () {
+        if (
+          (0 === (n ? n.readyState : -1)
+            ? console.log("[Braze Real-Time] Failed to connect")
+            : console.log("[Braze Real-Time] Connection lost"),
+          e && oe !== n)
+        )
+          return (
+            console.log(
+              "[Braze Real-Time] Gapless reconnection failed, keeping old connection",
+            ),
+            n.close(),
+            (ae = !1),
+            void (le < 5 && he())
+          );
+        ge(),
+          le < 5
+            ? he()
+            : (console.error("[Braze Real-Time] Max retries reached"),
+              fe({ type: "error", error: "Max retry attempts reached" }));
+      });
+  } catch (e) {
+    (ae = !1),
+      console.error("[Braze Real-Time] Failed to create EventSource:", e),
+      fe({ type: "error", error: String(e) });
+  }
+}
+function Be(e, n, o) {
+  switch (o.type) {
+    case "connect":
+      !te ||
+        (te.mite === o.pn.mite && te.ki === o.pn.ki) ||
+        (console.log("[Braze Real-Time] Config changed, reconnecting"),
+        ge(),
+        (le = 0),
+        (ie = null),
+        (se = null)),
+        (te = o.pn),
+        Te(),
+        oe || ae ? oe && e.postMessage({ type: "connected" }) : ze();
+      break;
+    case "disconnect":
+      re.delete(n),
+        n === me && ((me = null), Te()),
+        0 === re.size &&
+          (console.log("[Braze Real-Time] No more ports, closing connection"),
+          ge(),
+          (te = null),
+          (se = null),
+          (me = null));
+      break;
+    case "tab_active":
+      !(function (e) {
+        re.has(e) &&
+          me !== e &&
+          ((me = e),
+          console.log(
+            "[Braze Real-Time] Promoted to leader (tab became active):",
+            e,
+          ));
+      })(n);
+      break;
+    case "ping":
+      e.postMessage({ type: "pong" });
+      break;
+    default:
+      console.warn("[Braze Real-Time] Unknown message type:", o.type);
+  }
+}
+(pe.mn = ze),
+  (pe.Se = function (e) {
+    try {
+      const t = JSON.parse(e);
+      if (!t.type)
+        return void console.warn("[Braze Real-Time] Message without type:", t);
+      if ("ttl" === t.type && t.body)
+        return (
+          (n = t.body.He),
+          (o = t.body.Je),
+          void (
+            "number" == typeof n &&
+            ("string" == typeof o && (se = o),
+            console.log(
+              "[Braze Real-Time] TTL set to " +
+                n +
+                "ms, will perform gapless reconnection when expired",
+            ),
+            null !== ue && clearTimeout(ue),
+            (ue = setTimeout(function () {
+              (ue = null),
+                console.log(
+                  "[Braze Real-Time] TTL expired, performing gapless reconnection",
+                ),
+                ze(oe || void 0);
+            }, n)))
+          )
+        );
+      if ("ddr" === t.type && t.body)
+        return void (function (e, n) {
+          if ("number" != typeof e) return;
+          const o = Math.random() * e * 0.3,
+            t = Math.round(e + o),
+            l = n ? " (" + n + ")" : "";
+          console.log(
+            "[Braze Real-Time] Admin requested disconnect" +
+              l +
+              ", reconnecting in " +
+              t +
+              "ms",
+          ),
+            null !== de && clearTimeout(de),
+            ge(),
+            (de = setTimeout(function () {
+              (de = null), pe.mn();
+            }, t));
+        })(t.body.Ge, t.body.e);
+      console.log(
+        "[Braze Real-Time] Routing '" + t.type + "' message to leader",
+      ),
+        Re({ type: "message", data: t });
+    } catch (e) {
+      console.warn("[Braze Real-Time] Failed to parse message:", e);
+    }
+    var n, o;
+  }),
+  (ne.onconnect = function (e) {
+    const n = e.ports[0],
+      o = "port-" + Date.now() + "-" + Math.random().toString(36).substr(2, 9);
+    re.set(o, { port: n }),
+      (n.onmessage = function (e) {
+        try {
+          Be(n, o, e.data);
+        } catch (e) {
+          console.error("[Braze Real-Time] Error handling message:", e);
+        }
+      }),
+      (n.onmessageerror = function () {
+        console.warn("[Braze Real-Time] Message error from port:", o),
+          re.delete(o);
+      }),
+      n.start();
+  });

package/src/DUST/dust-worker-bridge.js

@@ -0,0 +1,136 @@
+import { logger as E } from "../../shared-lib/index.js";
+import { DUST_SHARED_WORKER_CODE as ri } from "./dust-shared-worker-code.js";
+export function isSharedWorkerSupported() {
+  return "undefined" != typeof SharedWorker;
+}
+export class DustWorkerBridge {
+  constructor(i) {
+    (this.Wr = null),
+      (this.Lr = null),
+      (this.isConnected = !1),
+      (this.Ir = null),
+      (this.Mr = null),
+      (this.we = i.we),
+      (this.ke = i.ke),
+      (this.Re = i.Re),
+      (this.Me = i.Me);
+  }
+  initialize() {
+    if (!isSharedWorkerSupported())
+      return (
+        E.info("SharedWorker not supported, will use direct connection"), !1
+      );
+    try {
+      const i = new Blob([ri], { type: "application/javascript" });
+      return (
+        (this.Lr = URL.createObjectURL(i)),
+        (this.Wr = new SharedWorker(this.Lr, { name: "braze-dust-worker" })),
+        (this.Wr.port.onmessage = (i) => {
+          this.Br(i.data);
+        }),
+        (this.Wr.port.onmessageerror = () => {
+          E.warn("Message error from real-time messaging worker");
+        }),
+        (this.Wr.onerror = (i) => {
+          var e;
+          E.error(
+            `Real-time messaging worker error: ${i.message || "unknown error"}`,
+          ),
+            null === (e = this.Me) ||
+              void 0 === e ||
+              e.call(this, "SharedWorker error");
+        }),
+        this.Wr.port.start(),
+        this.Ur(),
+        this.Vr(),
+        E.info("Real-time messaging worker initialized"),
+        !0
+      );
+    } catch (i) {
+      return (
+        E.error(
+          `Failed to create real-time messaging worker: ${
+            i instanceof Error ? i.message : String(i)
+          }`,
+        ),
+        this.Er(),
+        !1
+      );
+    }
+  }
+  Br(i) {
+    var e, t, s;
+    switch (i.type) {
+      case "connected":
+        E.info("Real-time messaging connection established via SharedWorker"),
+          (this.isConnected = !0),
+          null === (e = this.ke) || void 0 === e || e.call(this);
+        break;
+      case "disconnected":
+        E.info("Real-time messaging connection closed via SharedWorker"),
+          (this.isConnected = !1),
+          null === (t = this.Re) || void 0 === t || t.call(this);
+        break;
+      case "message":
+        this.we(i.data);
+        break;
+      case "error":
+        E.error(`Real-time messaging error: ${i.error}`),
+          null === (s = this.Me) || void 0 === s || s.call(this, i.error);
+    }
+  }
+  Ur() {
+    this.Ir = window.setInterval(() => {
+      this.Wr && this._r({ type: "ping" });
+    }, 3e4);
+  }
+  qr() {
+    null !== this.Ir && (window.clearInterval(this.Ir), (this.Ir = null));
+  }
+  Vr() {
+    (this.Mr = () => {
+      "visible" === document.visibilityState &&
+        this.Wr &&
+        this._r({ type: "tab_active" });
+    }),
+      document.addEventListener("visibilitychange", this.Mr);
+  }
+  Ar() {
+    this.Mr &&
+      (document.removeEventListener("visibilitychange", this.Mr),
+      (this.Mr = null));
+  }
+  _r(i) {
+    this.Wr && this.Wr.port.postMessage(i);
+  }
+  connect(i) {
+    this.Wr
+      ? (this._r({ type: "connect", pn: i }),
+        E.info("Connecting to real-time messaging"))
+      : E.error("Cannot connect: real-time messaging worker not initialized");
+  }
+  disconnect() {
+    this.Wr &&
+      (this._r({ type: "disconnect" }),
+      (this.isConnected = !1),
+      E.info("Disconnecting from real-time messaging"));
+  }
+  Ie() {
+    return this.isConnected;
+  }
+  isInitialized() {
+    return null !== this.Wr;
+  }
+  Er() {
+    this.qr(),
+      this.Ar(),
+      this.Wr && (this.Wr.port.close(), (this.Wr = null)),
+      this.Lr && (URL.revokeObjectURL(this.Lr), (this.Lr = null)),
+      (this.isConnected = !1);
+  }
+  destroy() {
+    this.disconnect(),
+      this.Er(),
+      E.info("Real-time messaging worker destroyed");
+  }
+}

package/src/DUST/index.js

@@ -0,0 +1,13 @@
+export { default as DustProviderFactory } from "./dust-provider-factory.js";
+export { default as DustProvider } from "./dust-provider.js";
+export { subscribeToDust } from "./subscribe-to-dust.js";
+export {
+  DustWorkerBridge,
+  isSharedWorkerSupported,
+} from "./dust-worker-bridge.js";
+export {
+  calculateBackoff,
+  buildSseUrl,
+  MIN_BACKOFF_MS,
+  MAX_BACKOFF_MS,
+} from "./dust-connection-core.js";

package/src/DUST/subscribe-to-dust.js

@@ -0,0 +1,24 @@
+import r from "../managers/braze-instance.js";
+import nr from "./dust-provider-factory.js";
+export function subscribeToDust() {
+  const t = r.l(),
+    n = r.nn();
+  if (!t || !n) return null;
+  const o = nr.o(),
+    s = () => {
+      if (!o.St()) {
+        o.Oe();
+        const r = n.rn(() => {
+          t.Ye() && o.Xe();
+        });
+        return r && o.wt(r), o.Ke() && o.qe(), r;
+      }
+      return o.St();
+    };
+  return (
+    t.Tr(() => {
+      r.ao() && (t.Ye() ? (o.Xe(), s()) : (o.Pe(), o.Ke() && o.Ae()));
+    }),
+    t.Ye() ? s() : null
+  );
+}

package/src/DUST/types.js

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

package/src/FeatureFlags/feature-flag-factory.js

@@ -1,22 +1,22 @@
 import { logger as E } from "../../shared-lib/index.js";
 import FeatureFlag from "./feature-flag.js";
 export function newFeatureFlagFromJson(e) {
-  if (e[FeatureFlag.ui.rs] && "boolean" == typeof e[FeatureFlag.ui.Fe])
+  if (e[FeatureFlag.ui.rs] && "boolean" == typeof e[FeatureFlag.ui.Jr])
     return new FeatureFlag(
       e[FeatureFlag.ui.rs],
-      e[FeatureFlag.ui.Fe],
-      e[FeatureFlag.ui.we],
-      e[FeatureFlag.ui.xe],
+      e[FeatureFlag.ui.Jr],
+      e[FeatureFlag.ui.Nr],
+      e[FeatureFlag.ui.Or],
     );
   E.info(`Unable to create feature flag from ${JSON.stringify(e, null, 2)}`);
 }
 export function newFeatureFlagFromSerializedValue(e) {
-  if (e[FeatureFlag.ss.rs] && "boolean" == typeof e[FeatureFlag.ss.Fe])
+  if (e[FeatureFlag.ss.rs] && "boolean" == typeof e[FeatureFlag.ss.Jr])
     return new FeatureFlag(
       e[FeatureFlag.ss.rs],
-      e[FeatureFlag.ss.Fe],
-      e[FeatureFlag.ss.we],
-      e[FeatureFlag.ss.xe],
+      e[FeatureFlag.ss.Jr],
+      e[FeatureFlag.ss.Nr],
+      e[FeatureFlag.ss.Or],
     );
   E.info(
     `Unable to deserialize feature flag from ${JSON.stringify(e, null, 2)}`,

package/src/FeatureFlags/feature-flag.js

@@ -9,16 +9,16 @@ export default class FeatureFlag extends p {
       (this.enabled = t),
       (this.trackingString = e);
   }
-  dt() {
+  gt() {
     const s = {};
     return (
       (s[FeatureFlag.ss.rs] = this.id),
-      (s[FeatureFlag.ss.Fe] = this.enabled),
-      (s[FeatureFlag.ss.we] = this.properties),
-      (s[FeatureFlag.ss.xe] = this.trackingString),
+      (s[FeatureFlag.ss.Jr] = this.enabled),
+      (s[FeatureFlag.ss.Nr] = this.properties),
+      (s[FeatureFlag.ss.Or] = this.trackingString),
       s
     );
   }
 }
-(FeatureFlag.ss = { rs: "id", Fe: "e", we: "pr", xe: "fts" }),
-  (FeatureFlag.ui = { rs: "id", Fe: "enabled", we: "properties", xe: "fts" });
+(FeatureFlag.ss = { rs: "id", Jr: "e", Nr: "pr", Or: "fts" }),
+  (FeatureFlag.ui = { rs: "id", Jr: "enabled", Nr: "properties", Or: "fts" });

package/src/FeatureFlags/feature-flags-provider-factory.js

@@ -1,19 +1,19 @@
 import r from "../managers/braze-instance.js";
-import tr from "./feature-flags-provider.js";
-const nr = {
+import ar from "./feature-flags-provider.js";
+const lr = {
   i: !1,
   provider: null,
   o: () => (
-    nr.t(),
-    nr.provider ||
-      ((nr.provider = new tr(r.l(), r.m(), r.p(), r.u())), r.v(nr.provider)),
-    nr.provider
+    lr.t(),
+    lr.provider ||
+      ((lr.provider = new ar(r.l(), r.m(), r.p(), r.u())), r.v(lr.provider)),
+    lr.provider
   ),
   t: () => {
-    nr.i || (r.g(nr), (nr.i = !0));
+    lr.i || (r.g(lr), (lr.i = !0));
   },
   destroy: () => {
-    (nr.provider = null), (nr.i = !1);
+    (lr.provider = null), (lr.i = !1);
   },
 };
-export default nr;
+export default lr;