@braze/web-sdk 6.4.0 → 6.5.0

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

@@ -0,0 +1,2 @@
+export const DUST_SHARED_WORKER_CODE =
+  '\n"use strict";\nconst workerSelf = self;\nlet eventSource = null;\nlet currentConfig = null;\nlet retryCount = 0;\nlet retryTimeoutId = null;\nlet connectionInProgress = false;\nconst maxRetries = 5;\nconst connectedPorts = new Map();\nlet lastSleepMs = null;\nlet currentRcs = null;\nlet ttlTimeoutId = null;\nlet leaderPortId = null;\nlet ddrTimeoutId = null;\nconst fn = {\n    startConnection: null,\n    handleMessage: null,\n};\nfunction broadcast(message) {\n    connectedPorts.forEach((portInfo, portId) => {\n        try {\n            portInfo.port.postMessage(message);\n        }\n        catch (_a) {\n            connectedPorts.delete(portId);\n        }\n    });\n}\nfunction randomInclusive(min, max) {\n    return Math.floor(Math.random() * (max - min + 1)) + min;\n}\nfunction electLeader() {\n    if (leaderPortId && connectedPorts.has(leaderPortId)) {\n        return;\n    }\n    const firstPortId = connectedPorts.keys().next().value;\n    leaderPortId = firstPortId || null;\n    if (leaderPortId) {\n        console.log("[Braze Real-Time] Elected leader port:", leaderPortId);\n    }\n}\nfunction promoteToLeader(portId) {\n    if (connectedPorts.has(portId) && leaderPortId !== portId) {\n        leaderPortId = portId;\n        console.log("[Braze Real-Time] Promoted to leader (tab became active):", portId);\n    }\n}\nfunction sendToLeader(message) {\n    electLeader();\n    if (!leaderPortId) {\n        console.warn("[Braze Real-Time] No leader to send message to");\n        return;\n    }\n    const leader = connectedPorts.get(leaderPortId);\n    if (leader) {\n        try {\n            leader.port.postMessage(message);\n        }\n        catch (_a) {\n            connectedPorts.delete(leaderPortId);\n            leaderPortId = null;\n            sendToLeader(message);\n        }\n    }\n}\nfunction closeConnection() {\n    connectionInProgress = false;\n    if (retryTimeoutId !== null) {\n        clearTimeout(retryTimeoutId);\n        retryTimeoutId = null;\n    }\n    if (ttlTimeoutId !== null) {\n        clearTimeout(ttlTimeoutId);\n        ttlTimeoutId = null;\n    }\n    if (ddrTimeoutId !== null) {\n        clearTimeout(ddrTimeoutId);\n        ddrTimeoutId = null;\n    }\n    if (eventSource) {\n        eventSource.close();\n        eventSource = null;\n        broadcast({ type: "disconnected" });\n    }\n}\nfunction retryWithBackoff() {\n    if (!currentConfig) {\n        return;\n    }\n    retryCount++;\n    const { minSleepMs, maxSleepMs, scaleFactor } = currentConfig.backoff;\n    let previousSleepMs = lastSleepMs;\n    if (previousSleepMs == null || previousSleepMs < minSleepMs) {\n        previousSleepMs = minSleepMs;\n    }\n    const backoffMs = Math.min(maxSleepMs, randomInclusive(minSleepMs, previousSleepMs * scaleFactor));\n    lastSleepMs = backoffMs;\n    console.log("[Braze Real-Time] Retrying in " + backoffMs + "ms (attempt " + retryCount + "/" + maxRetries + ")");\n    retryTimeoutId = setTimeout(function () {\n        retryTimeoutId = null;\n        fn.startConnection();\n    }, backoffMs);\n}\nfunction startConnection(oldEventSourceToClose) {\n    if (!currentConfig) {\n        return;\n    }\n    if (eventSource && !oldEventSourceToClose) {\n        console.warn("[Braze Real-Time] Connection already exists");\n        return;\n    }\n    if (connectionInProgress && !oldEventSourceToClose) {\n        console.warn("[Braze Real-Time] Connection attempt already in progress");\n        return;\n    }\n    connectionInProgress = true;\n    const { dustHost, mite, auth } = currentConfig;\n    const dustHostWithScheme = /^https?:\\/\\//i.test(dustHost) ? dustHost : "https://" + dustHost;\n    let queryString = "mite=" + encodeURIComponent(mite) + "&attempts=" + retryCount;\n    if (auth) {\n        queryString += "&auth=" + encodeURIComponent(auth);\n    }\n    if (currentRcs) {\n        queryString += "&rcs=" + encodeURIComponent(currentRcs);\n    }\n    const subscribeUrl = dustHostWithScheme + "/sse?" + queryString;\n    try {\n        const newEventSource = new EventSource(subscribeUrl);\n        newEventSource.onopen = function () {\n            if (oldEventSourceToClose) {\n                console.log("[Braze Real-Time] Gapless reconnection: new connection established, closing old connection");\n                oldEventSourceToClose.close();\n            }\n            else {\n                console.log("[Braze Real-Time] Connection established");\n            }\n            eventSource = newEventSource;\n            connectionInProgress = false;\n            retryCount = 0;\n            lastSleepMs = null;\n            broadcast({ type: "connected" });\n        };\n        newEventSource.addEventListener("msg", function (event) {\n            fn.handleMessage(event.data);\n        });\n        newEventSource.onerror = function () {\n            const readyState = newEventSource ? newEventSource.readyState : -1;\n            if (readyState === 0) {\n                console.log("[Braze Real-Time] Failed to connect");\n            }\n            else {\n                console.log("[Braze Real-Time] Connection lost");\n            }\n            if (oldEventSourceToClose && eventSource !== newEventSource) {\n                console.log("[Braze Real-Time] Gapless reconnection failed, keeping old connection");\n                newEventSource.close();\n                connectionInProgress = false;\n                if (retryCount < maxRetries) {\n                    retryWithBackoff();\n                }\n                return;\n            }\n            closeConnection();\n            if (retryCount < maxRetries) {\n                retryWithBackoff();\n            }\n            else {\n                console.error("[Braze Real-Time] Max retries reached");\n                broadcast({ type: "error", error: "Max retry attempts reached" });\n            }\n        };\n    }\n    catch (error) {\n        connectionInProgress = false;\n        console.error("[Braze Real-Time] Failed to create EventSource:", error);\n        broadcast({ type: "error", error: String(error) });\n    }\n}\nfunction handleTtlMessage(tMs, rcs) {\n    if (typeof tMs !== "number") {\n        return;\n    }\n    if (typeof rcs === "string") {\n        currentRcs = rcs;\n    }\n    console.log("[Braze Real-Time] TTL set to " + tMs + "ms, will perform gapless reconnection when expired");\n    if (ttlTimeoutId !== null) {\n        clearTimeout(ttlTimeoutId);\n    }\n    ttlTimeoutId = setTimeout(function () {\n        ttlTimeoutId = null;\n        console.log("[Braze Real-Time] TTL expired, performing gapless reconnection");\n        startConnection(eventSource || undefined);\n    }, tMs);\n}\nfunction handleDdrMessage(rMs, reason) {\n    if (typeof rMs !== "number") {\n        return;\n    }\n    const jitter = Math.random() * rMs * 0.3;\n    const waitMs = Math.round(rMs + jitter);\n    const reasonStr = reason ? " (" + reason + ")" : "";\n    console.log("[Braze Real-Time] Admin requested disconnect" + reasonStr + ", reconnecting in " + waitMs + "ms");\n    if (ddrTimeoutId !== null) {\n        clearTimeout(ddrTimeoutId);\n    }\n    closeConnection();\n    ddrTimeoutId = setTimeout(function () {\n        ddrTimeoutId = null;\n        fn.startConnection();\n    }, waitMs);\n}\nfunction handleMessage(data) {\n    try {\n        const message = JSON.parse(data);\n        if (!message.type) {\n            console.warn("[Braze Real-Time] Message without type:", message);\n            return;\n        }\n        if (message.type === "ttl" && message.body) {\n            handleTtlMessage(message.body.t_ms, message.body.rcs);\n            return;\n        }\n        if (message.type === "ddr" && message.body) {\n            handleDdrMessage(message.body.r_ms, message.body.e);\n            return;\n        }\n        console.log("[Braze Real-Time] Routing \'" + message.type + "\' message to leader");\n        sendToLeader({ type: "message", data: message });\n    }\n    catch (error) {\n        console.warn("[Braze Real-Time] Failed to parse message:", error);\n    }\n}\nfn.startConnection = startConnection;\nfn.handleMessage = handleMessage;\nfunction handlePortMessage(port, portId, message) {\n    switch (message.type) {\n        case "connect":\n            if (currentConfig &&\n                (currentConfig.mite !== message.config.mite || currentConfig.dustHost !== message.config.dustHost)) {\n                console.log("[Braze Real-Time] Config changed, reconnecting");\n                closeConnection();\n                retryCount = 0;\n                lastSleepMs = null;\n                currentRcs = null;\n            }\n            currentConfig = message.config;\n            electLeader();\n            if (!eventSource && !connectionInProgress) {\n                startConnection();\n            }\n            else if (eventSource) {\n                port.postMessage({ type: "connected" });\n            }\n            break;\n        case "disconnect":\n            connectedPorts.delete(portId);\n            if (portId === leaderPortId) {\n                leaderPortId = null;\n                electLeader();\n            }\n            if (connectedPorts.size === 0) {\n                console.log("[Braze Real-Time] No more ports, closing connection");\n                closeConnection();\n                currentConfig = null;\n                currentRcs = null;\n                leaderPortId = null;\n            }\n            break;\n        case "tab_active":\n            promoteToLeader(portId);\n            break;\n        case "ping":\n            port.postMessage({ type: "pong" });\n            break;\n        default:\n            console.warn("[Braze Real-Time] Unknown message type:", message.type);\n    }\n}\nworkerSelf.onconnect = function (event) {\n    const port = event.ports[0];\n    const portId = "port-" + Date.now() + "-" + Math.random().toString(36).substr(2, 9);\n    connectedPorts.set(portId, { port: port });\n    port.onmessage = function (messageEvent) {\n        try {\n            handlePortMessage(port, portId, messageEvent.data);\n        }\n        catch (error) {\n            console.error("[Braze Real-Time] Error handling message:", error);\n        }\n    };\n    port.onmessageerror = function () {\n        console.warn("[Braze Real-Time] Message error from port:", portId);\n        connectedPorts.delete(portId);\n    };\n    port.start();\n};\n';

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

@@ -1,3 +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

@@ -1,24 +1,24 @@
 import r from "../managers/braze-instance.js";
-import ir from "./dust-provider-factory.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 = ir.o(),
+  const o = nr.o(),
     s = () => {
-      if (!o.jt()) {
-        o.Hi();
+      if (!o.St()) {
+        o.Oe();
         const r = n.rn(() => {
-          t.Xi() && o.Vi();
+          t.Ye() && o.Xe();
         });
-        return r && o.yt(r), o.Wi() && o.Gi(), r;
+        return r && o.wt(r), o.Ke() && o.qe(), r;
       }
-      return o.jt();
+      return o.St();
     };
-  return t.Xi()
-    ? s()
-    : (t.Tr(() => {
-        r.ao() && t.Xi() && (o.Vi(), s());
-      }),
-      null);
+  return (
+    t.Tr(() => {
+      r.ao() && (t.Ye() ? (o.Xe(), s()) : (o.Pe(), o.Ke() && o.Ae()));
+    }),
+    t.Ye() ? s() : null
+  );
 }

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 nr from "./feature-flags-provider.js";
-const ar = {
+import ar from "./feature-flags-provider.js";
+const lr = {
   i: !1,
   provider: null,
   o: () => (
-    ar.t(),
-    ar.provider ||
-      ((ar.provider = new nr(r.l(), r.m(), r.p(), r.u())), r.v(ar.provider)),
-    ar.provider
+    lr.t(),
+    lr.provider ||
+      ((lr.provider = new ar(r.l(), r.m(), r.p(), r.u())), r.v(lr.provider)),
+    lr.provider
   ),
   t: () => {
-    ar.i || (r.g(ar), (ar.i = !0));
+    lr.i || (r.g(lr), (lr.i = !0));
   },
   destroy: () => {
-    (ar.provider = null), (ar.i = !1);
+    (lr.provider = null), (lr.i = !1);
   },
 };
-export default ar;
+export default lr;