@novu/js 3.5.1-nightly.20250610 → 3.6.0-nightly.20250720

package/dist/esm/{chunk-25DDNKEO.mjs → chunk-MBD22VX3.mjs}

@@ -1,6 +1,8 @@
-import { __privateAdd, __privateSet, __privateGet, __async, __objRest, __spreadValues, __privateMethod, __spreadProps } from './chunk-STZMOEWR.mjs';
+import { buildSubscriber } from './chunk-KYYDDVBR.mjs';
+import { __privateAdd, __privateSet, __privateGet, __async, __objRest, __spreadValues, __spreadProps, __privateMethod } from './chunk-STZMOEWR.mjs';
 import mitt from 'mitt';
 import io from 'socket.io-client';
+import { WebSocket } from 'partysocket';
 
 // src/types.ts
 var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
@@ -62,12 +64,12 @@ var areDataEqual = (data1, data2) => {
   }
 };
 var isSameFilter = (filter1, filter2) => {
-  return areDataEqual(filter1.data, filter2.data) && areTagsEqual(filter1.tags, filter2.tags) && filter1.read === filter2.read && filter1.archived === filter2.archived && filter1.snoozed === filter2.snoozed;
+  return areDataEqual(filter1.data, filter2.data) && areTagsEqual(filter1.tags, filter2.tags) && filter1.read === filter2.read && filter1.archived === filter2.archived && filter1.snoozed === filter2.snoozed && filter1.seen === filter2.seen;
 };
 
 // src/api/http-client.ts
 var DEFAULT_API_VERSION = "v1";
-var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.5.1-nightly.20250610"}`;
+var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.6.0-nightly.20250720"}`;
 var HttpClient = class {
   constructor(options = {}) {
     // Environment variable for local development that overrides the default API endpoint without affecting the Inbox DX
@@ -216,6 +218,7 @@ var InboxService = class {
     read: read2,
     tags,
     snoozed,
+    seen: seen2,
     data
   }) {
     const searchParams = new URLSearchParams(`limit=${limit}`);
@@ -237,6 +240,9 @@ var InboxService = class {
     if (snoozed !== void 0) {
       searchParams.append("snoozed", `${snoozed}`);
     }
+    if (seen2 !== void 0) {
+      searchParams.append("seen", `${seen2}`);
+    }
     if (data !== void 0) {
       searchParams.append("data", JSON.stringify(data));
     }
@@ -284,11 +290,25 @@ var InboxService = class {
     });
   }
   archiveAllRead({ tags, data }) {
-    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/read-archive`, {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/archive/read`, {
       tags,
       data: data ? JSON.stringify(data) : void 0
     });
   }
+  markAsSeen({
+    notificationIds,
+    tags,
+    data
+  }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/seen`, {
+      notificationIds,
+      tags,
+      data: data ? JSON.stringify(data) : void 0
+    });
+  }
+  seen(notificationId) {
+    return this.markAsSeen({ notificationIds: [notificationId] });
+  }
   completeAction({
     actionType,
     notificationId
@@ -437,12 +457,14 @@ var Notification = class {
     this.body = notification.body;
     this.to = notification.to;
     this.isRead = notification.isRead;
+    this.isSeen = notification.isSeen;
     this.isArchived = notification.isArchived;
     this.isSnoozed = notification.isSnoozed;
     this.snoozedUntil = notification.snoozedUntil;
     this.deliveredAt = notification.deliveredAt;
     this.createdAt = notification.createdAt;
     this.readAt = notification.readAt;
+    this.firstSeenAt = notification.firstSeenAt;
     this.archivedAt = notification.archivedAt;
     this.avatar = notification.avatar;
     this.primaryAction = notification.primaryAction;
@@ -471,6 +493,15 @@ var Notification = class {
       }
     });
   }
+  seen() {
+    return seen({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      }
+    });
+  }
   archive() {
     return archive({
       emitter: __privateGet(this, _emitter),
@@ -640,6 +671,38 @@ var unread = (_0) => __async(void 0, [_0], function* ({
     return { error: new NovuError("Failed to unread notification", error) };
   }
 });
+var seen = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  const { notificationId, optimisticValue } = getNotificationDetails(
+    args,
+    {
+      isSeen: true
+    },
+    {
+      emitter,
+      apiService
+    }
+  );
+  try {
+    emitter.emit("notification.seen.pending", {
+      args,
+      data: optimisticValue
+    });
+    yield apiService.seen(notificationId);
+    if (!optimisticValue) {
+      throw new Error("Failed to create optimistic value for notification");
+    }
+    const updatedNotification = new Notification(optimisticValue, emitter, apiService);
+    emitter.emit("notification.seen.resolved", { args, data: updatedNotification });
+    return { data: updatedNotification };
+  } catch (error) {
+    emitter.emit("notification.seen.resolved", { args, error });
+    return { error: new NovuError("Failed to mark notification as seen", error) };
+  }
+});
 var archive = (_0) => __async(void 0, [_0], function* ({
   emitter,
   apiService,
@@ -876,6 +939,42 @@ var readAll = (_0) => __async(void 0, [_0], function* ({
     return { error: new NovuError("Failed to read all notifications", error) };
   }
 });
+var seenAll = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  inboxService,
+  notificationsCache,
+  notificationIds,
+  tags,
+  data
+}) {
+  try {
+    const notifications = notificationsCache.getUniqueNotifications({ tags, data });
+    const filteredNotifications = notificationIds && notificationIds.length > 0 ? notifications.filter((notification) => notificationIds.includes(notification.id)) : notifications;
+    const optimisticNotifications = filteredNotifications.map(
+      (notification) => new Notification(
+        __spreadProps(__spreadValues({}, notification), {
+          isSeen: true,
+          firstSeenAt: notification.firstSeenAt || (/* @__PURE__ */ new Date()).toISOString()
+        }),
+        emitter,
+        inboxService
+      )
+    );
+    emitter.emit("notifications.seen_all.pending", {
+      args: { notificationIds, tags, data },
+      data: optimisticNotifications
+    });
+    yield inboxService.markAsSeen({ notificationIds, tags, data });
+    emitter.emit("notifications.seen_all.resolved", {
+      args: { notificationIds, tags, data },
+      data: optimisticNotifications
+    });
+    return {};
+  } catch (error) {
+    emitter.emit("notifications.seen_all.resolved", { args: { notificationIds, tags, data }, error });
+    return { error: new NovuError("Failed to mark all notifications as seen", error) };
+  }
+});
 var archiveAll = (_0) => __async(void 0, [_0], function* ({
   emitter,
   inboxService,
@@ -964,21 +1063,32 @@ var InMemoryCache = class {
 _cache = new WeakMap();
 
 // src/cache/notifications-cache.ts
-var excludeEmpty = ({ tags, data, read: read2, archived, snoozed, limit, offset, after }) => Object.entries({ tags, data, read: read2, archived, snoozed, limit, offset, after }).filter(([_, value]) => value !== null && value !== void 0 && !(Array.isArray(value) && value.length === 0)).reduce((acc, [key, value]) => {
+var excludeEmpty = ({ tags, data, read: read2, archived, snoozed, seen: seen2, limit, offset, after }) => Object.entries({ tags, data, read: read2, archived, snoozed, seen: seen2, limit, offset, after }).filter(([_, value]) => value !== null && value !== void 0 && !(Array.isArray(value) && value.length === 0)).reduce((acc, [key, value]) => {
   acc[key] = value;
   return acc;
 }, {});
-var getCacheKey = ({ tags, data, read: read2, archived, snoozed, limit, offset, after }) => {
-  return JSON.stringify(excludeEmpty({ tags, data, read: read2, archived, snoozed, limit, offset, after }));
+var getCacheKey = ({
+  tags,
+  data,
+  read: read2,
+  archived,
+  snoozed,
+  seen: seen2,
+  limit,
+  offset,
+  after
+}) => {
+  return JSON.stringify(excludeEmpty({ tags, data, read: read2, archived, snoozed, seen: seen2, limit, offset, after }));
 };
 var getFilterKey = ({
   tags,
   data,
   read: read2,
   archived,
-  snoozed
+  snoozed,
+  seen: seen2
 }) => {
-  return JSON.stringify(excludeEmpty({ tags, data, read: read2, archived, snoozed }));
+  return JSON.stringify(excludeEmpty({ tags, data, read: read2, archived, snoozed, seen: seen2 }));
 };
 var getFilter = (key) => {
   return JSON.parse(key);
@@ -1115,7 +1225,8 @@ var NotificationsCache = class {
         data: args.data,
         read: args.read,
         snoozed: args.snoozed,
-        archived: args.archived
+        archived: args.archived,
+        seen: args.seen
       });
     }
   }
@@ -1175,6 +1286,9 @@ var Notifications = class extends BaseModule {
     });
     __privateSet(this, _useCache, useCache);
   }
+  get inboxService() {
+    return this._inboxService;
+  }
   list() {
     return __async(this, arguments, function* (_a = {}) {
       var _b = _a, { limit = 10 } = _b, restOptions = __objRest(_b, ["limit"]);
@@ -1255,6 +1369,19 @@ var Notifications = class extends BaseModule {
       );
     });
   }
+  seen(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => __async(this, null, function* () {
+          return seen({
+            emitter: this._emitter,
+            apiService: this._inboxService,
+            args
+          });
+        })
+      );
+    });
+  }
   archive(args) {
     return __async(this, null, function* () {
       return this.callWithSession(
@@ -1381,6 +1508,28 @@ var Notifications = class extends BaseModule {
       );
     });
   }
+  seenAll() {
+    return __async(this, arguments, function* (args = {}) {
+      return this.callWithSession(() => __async(this, null, function* () {
+        if ("notificationIds" in args) {
+          return seenAll({
+            emitter: this._emitter,
+            inboxService: this._inboxService,
+            notificationsCache: this.cache,
+            notificationIds: args.notificationIds
+          });
+        } else {
+          return seenAll({
+            emitter: this._emitter,
+            inboxService: this._inboxService,
+            notificationsCache: this.cache,
+            tags: "tags" in args ? args.tags : void 0,
+            data: "data" in args ? args.data : void 0
+          });
+        }
+      }));
+    });
+  }
   archiveAll() {
     return __async(this, arguments, function* ({
       tags,
@@ -1776,6 +1925,11 @@ var Preferences = class extends BaseModule {
 };
 _useCache3 = new WeakMap();
 
+// src/utils/is-browser.ts
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+
 // src/session/session.ts
 var _emitter5, _inboxService2, _options;
 var Session = class {
@@ -1819,12 +1973,19 @@ var Session = class {
   }
   initialize(options) {
     return __async(this, null, function* () {
-      var _a, _b;
+      var _a, _b, _c, _d, _e, _f;
+      if (((_a = __privateGet(this, _options).subscriber) == null ? void 0 : _a.subscriberId) === ((_b = options == null ? void 0 : options.subscriber) == null ? void 0 : _b.subscriberId)) {
+        return;
+      }
       try {
         if (options) {
           __privateSet(this, _options, options);
         }
         const { subscriber, subscriberHash, applicationIdentifier } = __privateGet(this, _options);
+        let currentTimezone;
+        if (isBrowser()) {
+          currentTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        }
         let finalApplicationIdentifier = applicationIdentifier;
         if (!finalApplicationIdentifier) {
           const storedAppId = this.handleApplicationIdentifier("get");
@@ -1838,12 +1999,15 @@ var Session = class {
         const response = yield __privateGet(this, _inboxService2).initializeSession({
           applicationIdentifier: finalApplicationIdentifier,
           subscriberHash,
-          subscriber
+          subscriber: __spreadProps(__spreadValues({}, subscriber), {
+            subscriberId: (_c = subscriber == null ? void 0 : subscriber.subscriberId) != null ? _c : "",
+            timezone: (_d = subscriber == null ? void 0 : subscriber.timezone) != null ? _d : currentTimezone
+          })
         });
-        if ((_a = response == null ? void 0 : response.applicationIdentifier) == null ? void 0 : _a.startsWith("pk_keyless_")) {
+        if ((_e = response == null ? void 0 : response.applicationIdentifier) == null ? void 0 : _e.startsWith("pk_keyless_")) {
           this.handleApplicationIdentifier("store", response.applicationIdentifier);
         }
-        if (!((_b = response == null ? void 0 : response.applicationIdentifier) == null ? void 0 : _b.startsWith("pk_keyless_"))) {
+        if (!((_f = response == null ? void 0 : response.applicationIdentifier) == null ? void 0 : _f.startsWith("pk_keyless_"))) {
           this.handleApplicationIdentifier("delete");
         }
         __privateGet(this, _emitter5).emit("session.initialize.resolved", { args: __privateGet(this, _options), data: response });
@@ -1864,11 +2028,13 @@ var mapToNotification = ({
   _id,
   content,
   read: read2,
+  seen: seen2,
   archived,
   snoozedUntil,
   deliveredAt,
   createdAt,
   lastReadDate,
+  firstSeenDate,
   archivedAt,
   channel,
   subscriber,
@@ -1902,6 +2068,7 @@ var mapToNotification = ({
     body: content,
     to,
     isRead: read2,
+    isSeen: seen2,
     isArchived: archived,
     isSnoozed: !!snoozedUntil
   }, deliveredAt && {
@@ -1911,6 +2078,7 @@ var mapToNotification = ({
   }), {
     createdAt,
     readAt: lastReadDate,
+    firstSeenAt: firstSeenDate,
     archivedAt,
     avatar,
     primaryAction: primaryCta && {
@@ -2052,59 +2220,330 @@ handleDisconnectSocket_fn = function() {
     }
   });
 };
+var PRODUCTION_SOCKET_URL2 = "wss://socket.novu.co";
+var NOTIFICATION_RECEIVED2 = "notifications.notification_received";
+var UNSEEN_COUNT_CHANGED2 = "notifications.unseen_count_changed";
+var UNREAD_COUNT_CHANGED2 = "notifications.unread_count_changed";
+var mapToNotification2 = ({
+  _id,
+  content,
+  read: read2,
+  seen: seen2,
+  archived,
+  snoozedUntil,
+  deliveredAt,
+  createdAt,
+  lastReadDate,
+  firstSeenDate,
+  archivedAt,
+  channel,
+  subscriber,
+  subject,
+  avatar,
+  cta,
+  tags,
+  data,
+  workflow
+}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const to = {
+    id: subscriber == null ? void 0 : subscriber._id,
+    subscriberId: subscriber == null ? void 0 : subscriber.subscriberId,
+    firstName: subscriber == null ? void 0 : subscriber.firstName,
+    lastName: subscriber == null ? void 0 : subscriber.lastName,
+    avatar: subscriber == null ? void 0 : subscriber.avatar,
+    locale: subscriber == null ? void 0 : subscriber.locale,
+    data: subscriber == null ? void 0 : subscriber.data,
+    timezone: subscriber == null ? void 0 : subscriber.timezone,
+    email: subscriber == null ? void 0 : subscriber.email,
+    phone: subscriber == null ? void 0 : subscriber.phone
+  };
+  const primaryCta = (_b = (_a = cta.action) == null ? void 0 : _a.buttons) == null ? void 0 : _b.find((button) => button.type === "primary" /* PRIMARY */);
+  const secondaryCta = (_d = (_c = cta.action) == null ? void 0 : _c.buttons) == null ? void 0 : _d.find((button) => button.type === "secondary" /* SECONDARY */);
+  const actionType = (_f = (_e = cta.action) == null ? void 0 : _e.result) == null ? void 0 : _f.type;
+  const actionStatus = (_g = cta.action) == null ? void 0 : _g.status;
+  return __spreadProps(__spreadValues(__spreadValues({
+    id: _id,
+    subject,
+    body: content,
+    to,
+    isRead: read2,
+    isSeen: seen2,
+    isArchived: archived,
+    isSnoozed: !!snoozedUntil
+  }, deliveredAt && {
+    deliveredAt
+  }), snoozedUntil && {
+    snoozedUntil
+  }), {
+    createdAt,
+    readAt: lastReadDate,
+    firstSeenAt: firstSeenDate,
+    archivedAt,
+    avatar,
+    primaryAction: primaryCta && {
+      label: primaryCta.content,
+      isCompleted: actionType === "primary" /* PRIMARY */ && actionStatus === "done" /* DONE */,
+      redirect: primaryCta.url ? {
+        target: primaryCta.target,
+        url: primaryCta.url
+      } : void 0
+    },
+    secondaryAction: secondaryCta && {
+      label: secondaryCta.content,
+      isCompleted: actionType === "secondary" /* SECONDARY */ && actionStatus === "done" /* DONE */,
+      redirect: secondaryCta.url ? {
+        target: secondaryCta.target,
+        url: secondaryCta.url
+      } : void 0
+    },
+    channelType: channel,
+    tags,
+    redirect: ((_h = cta.data) == null ? void 0 : _h.url) ? {
+      url: cta.data.url,
+      target: cta.data.target
+    } : void 0,
+    data,
+    workflow
+  });
+};
+var _token2, _emitter7, _partySocket, _socketUrl2, _notificationReceived2, _unseenCountChanged2, _unreadCountChanged2, _handleMessage, _PartySocketClient_instances, initializeSocket_fn2, handleConnectSocket_fn2, handleDisconnectSocket_fn2;
+var PartySocketClient = class extends BaseModule {
+  constructor({
+    socketUrl,
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
+    super({
+      eventEmitterInstance,
+      inboxServiceInstance
+    });
+    __privateAdd(this, _PartySocketClient_instances);
+    __privateAdd(this, _token2);
+    __privateAdd(this, _emitter7);
+    __privateAdd(this, _partySocket);
+    __privateAdd(this, _socketUrl2);
+    __privateAdd(this, _notificationReceived2, (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.event === "notification_received" /* RECEIVED */) {
+          __privateGet(this, _emitter7).emit(NOTIFICATION_RECEIVED2, {
+            result: new Notification(mapToNotification2(data.data.message), __privateGet(this, _emitter7), this._inboxService)
+          });
+        }
+      } catch (error) {
+        console.log("error", error);
+      }
+    });
+    __privateAdd(this, _unseenCountChanged2, (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.event === "unseen_count_changed" /* UNSEEN */) {
+          __privateGet(this, _emitter7).emit(UNSEEN_COUNT_CHANGED2, {
+            result: data.data.unseenCount
+          });
+        }
+      } catch (error) {
+      }
+    });
+    __privateAdd(this, _unreadCountChanged2, (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.event === "unread_count_changed" /* UNREAD */) {
+          __privateGet(this, _emitter7).emit(UNREAD_COUNT_CHANGED2, {
+            result: data.data.unreadCount
+          });
+        }
+      } catch (error) {
+      }
+    });
+    __privateAdd(this, _handleMessage, (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        switch (data.event) {
+          case "notification_received" /* RECEIVED */:
+            __privateGet(this, _notificationReceived2).call(this, event);
+            break;
+          case "unseen_count_changed" /* UNSEEN */:
+            __privateGet(this, _unseenCountChanged2).call(this, event);
+            break;
+          case "unread_count_changed" /* UNREAD */:
+            __privateGet(this, _unreadCountChanged2).call(this, event);
+            break;
+          default:
+        }
+      } catch (error) {
+      }
+    });
+    __privateSet(this, _emitter7, eventEmitterInstance);
+    __privateSet(this, _socketUrl2, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL2);
+  }
+  onSessionSuccess({ token }) {
+    __privateSet(this, _token2, token);
+  }
+  isSocketEvent(eventName) {
+    return eventName === NOTIFICATION_RECEIVED2 || eventName === UNSEEN_COUNT_CHANGED2 || eventName === UNREAD_COUNT_CHANGED2;
+  }
+  connect() {
+    return __async(this, null, function* () {
+      if (__privateGet(this, _token2)) {
+        return __privateMethod(this, _PartySocketClient_instances, handleConnectSocket_fn2).call(this);
+      }
+      return this.callWithSession(__privateMethod(this, _PartySocketClient_instances, handleConnectSocket_fn2).bind(this));
+    });
+  }
+  disconnect() {
+    return __async(this, null, function* () {
+      if (__privateGet(this, _partySocket)) {
+        return __privateMethod(this, _PartySocketClient_instances, handleDisconnectSocket_fn2).call(this);
+      }
+      return this.callWithSession(__privateMethod(this, _PartySocketClient_instances, handleDisconnectSocket_fn2).bind(this));
+    });
+  }
+};
+_token2 = new WeakMap();
+_emitter7 = new WeakMap();
+_partySocket = new WeakMap();
+_socketUrl2 = new WeakMap();
+_notificationReceived2 = new WeakMap();
+_unseenCountChanged2 = new WeakMap();
+_unreadCountChanged2 = new WeakMap();
+_handleMessage = new WeakMap();
+_PartySocketClient_instances = new WeakSet();
+initializeSocket_fn2 = function() {
+  return __async(this, null, function* () {
+    if (__privateGet(this, _partySocket)) {
+      return;
+    }
+    const args = { socketUrl: __privateGet(this, _socketUrl2) };
+    __privateGet(this, _emitter7).emit("socket.connect.pending", { args });
+    const url = new URL(__privateGet(this, _socketUrl2));
+    url.searchParams.set("token", __privateGet(this, _token2));
+    __privateSet(this, _partySocket, new WebSocket(url.toString()));
+    __privateGet(this, _partySocket).addEventListener("open", () => {
+      __privateGet(this, _emitter7).emit("socket.connect.resolved", { args });
+    });
+    __privateGet(this, _partySocket).addEventListener("error", (error) => {
+      __privateGet(this, _emitter7).emit("socket.connect.resolved", { args, error });
+    });
+    __privateGet(this, _partySocket).addEventListener("message", __privateGet(this, _handleMessage));
+  });
+};
+handleConnectSocket_fn2 = function() {
+  return __async(this, null, function* () {
+    try {
+      yield __privateMethod(this, _PartySocketClient_instances, initializeSocket_fn2).call(this);
+      return {};
+    } catch (error) {
+      return { error: new NovuError("Failed to initialize the PartySocket", error) };
+    }
+  });
+};
+handleDisconnectSocket_fn2 = function() {
+  return __async(this, null, function* () {
+    var _a;
+    try {
+      (_a = __privateGet(this, _partySocket)) == null ? void 0 : _a.close();
+      __privateSet(this, _partySocket, void 0);
+      return {};
+    } catch (error) {
+      return { error: new NovuError("Failed to disconnect from the PartySocket", error) };
+    }
+  });
+};
+
+// src/ws/socket-factory.ts
+var PARTY_SOCKET_URLS = [
+  "wss://eu.socket.novu.co",
+  PRODUCTION_SOCKET_URL2,
+  "wss://socket.novu-staging.co",
+  "wss://socket-worker-local.cli-shortener.workers.dev"
+];
+var URL_TRANSFORMATIONS = {
+  "https://eu.ws.novu.co": "wss://eu.socket.novu.co",
+  "https://ws.novu.co": PRODUCTION_SOCKET_URL2,
+  "https://dev.ws.novu.co": "wss://socket.novu-staging.co"
+};
+function transformSocketUrl(socketUrl) {
+  if (!socketUrl) return PRODUCTION_SOCKET_URL2;
+  return URL_TRANSFORMATIONS[socketUrl] || socketUrl;
+}
+function shouldUsePartySocket(socketUrl) {
+  return !socketUrl || PARTY_SOCKET_URLS.includes(socketUrl);
+}
+function createSocket({
+  socketUrl,
+  inboxServiceInstance,
+  eventEmitterInstance
+}) {
+  const transformedSocketUrl = transformSocketUrl(socketUrl);
+  const socketType = shouldUsePartySocket(transformedSocketUrl) ? "partysocket" /* PARTY_SOCKET */ : "socket.io" /* SOCKET_IO */;
+  switch (socketType) {
+    case "partysocket" /* PARTY_SOCKET */:
+      return new PartySocketClient({
+        socketUrl: transformedSocketUrl,
+        inboxServiceInstance,
+        eventEmitterInstance
+      });
+    case "socket.io" /* SOCKET_IO */:
+    default:
+      return new Socket({
+        socketUrl: transformedSocketUrl,
+        inboxServiceInstance,
+        eventEmitterInstance
+      });
+  }
+}
 
 // src/novu.ts
-var _emitter7, _session, _inboxService3, _currentSubscriberId;
+var _emitter8, _session, _inboxService3;
 var Novu = class {
   constructor(options) {
-    __privateAdd(this, _emitter7);
+    __privateAdd(this, _emitter8);
     __privateAdd(this, _session);
     __privateAdd(this, _inboxService3);
-    __privateAdd(this, _currentSubscriberId);
     var _a, _b;
     __privateSet(this, _inboxService3, new InboxService({
       apiUrl: options.apiUrl || options.backendUrl,
       userAgent: options.__userAgent
     }));
-    __privateSet(this, _emitter7, new NovuEventEmitter());
+    __privateSet(this, _emitter8, new NovuEventEmitter());
     __privateSet(this, _session, new Session(
       {
         applicationIdentifier: options.applicationIdentifier || "",
         subscriberHash: options.subscriberHash,
-        subscriber: buildSubscriber(options)
+        subscriber: buildSubscriber({ subscriberId: options.subscriberId, subscriber: options.subscriber })
       },
       __privateGet(this, _inboxService3),
-      __privateGet(this, _emitter7)
+      __privateGet(this, _emitter8)
     ));
-    const initialSubscriber = buildSubscriber(options);
-    __privateSet(this, _currentSubscriberId, initialSubscriber.subscriberId);
     __privateGet(this, _session).initialize();
     this.notifications = new Notifications({
       useCache: (_a = options.useCache) != null ? _a : true,
       inboxServiceInstance: __privateGet(this, _inboxService3),
-      eventEmitterInstance: __privateGet(this, _emitter7)
+      eventEmitterInstance: __privateGet(this, _emitter8)
     });
     this.preferences = new Preferences({
       useCache: (_b = options.useCache) != null ? _b : true,
       inboxServiceInstance: __privateGet(this, _inboxService3),
-      eventEmitterInstance: __privateGet(this, _emitter7)
+      eventEmitterInstance: __privateGet(this, _emitter8)
     });
-    this.socket = new Socket({
+    this.socket = createSocket({
       socketUrl: options.socketUrl,
-      eventEmitterInstance: __privateGet(this, _emitter7),
+      eventEmitterInstance: __privateGet(this, _emitter8),
       inboxServiceInstance: __privateGet(this, _inboxService3)
     });
     this.on = (eventName, listener) => {
       if (this.socket.isSocketEvent(eventName)) {
         this.socket.connect();
       }
-      const cleanup = __privateGet(this, _emitter7).on(eventName, listener);
+      const cleanup = __privateGet(this, _emitter8).on(eventName, listener);
       return () => {
         cleanup();
       };
     };
     this.off = (eventName, listener) => {
-      __privateGet(this, _emitter7).off(eventName, listener);
+      __privateGet(this, _emitter8).off(eventName, listener);
     };
   }
   get applicationIdentifier() {
@@ -2115,30 +2554,16 @@ var Novu = class {
   }
   changeSubscriber(options) {
     return __async(this, null, function* () {
-      if (__privateGet(this, _currentSubscriberId) === options.subscriber.subscriberId) {
-        return;
-      }
       yield __privateGet(this, _session).initialize({
         applicationIdentifier: __privateGet(this, _session).applicationIdentifier || "",
         subscriberHash: options.subscriberHash,
         subscriber: options.subscriber
       });
-      __privateSet(this, _currentSubscriberId, options.subscriber.subscriberId);
     });
   }
 };
-_emitter7 = new WeakMap();
+_emitter8 = new WeakMap();
 _session = new WeakMap();
 _inboxService3 = new WeakMap();
-_currentSubscriberId = new WeakMap();
-function buildSubscriber(options) {
-  if (options.subscriber) {
-    return typeof options.subscriber === "string" ? { subscriberId: options.subscriber } : options.subscriber;
-  }
-  if (options.subscriberId) {
-    return { subscriberId: options.subscriberId };
-  }
-  return { subscriberId: "" };
-}
 
-export { ChannelType, DEFAULT_API_VERSION, NotificationStatus, Novu, PreferenceLevel, WebSocketEvent, areTagsEqual, isSameFilter };
+export { ChannelType, DEFAULT_API_VERSION, NotificationStatus, Novu, PreferenceLevel, WebSocketEvent, areTagsEqual, isBrowser, isSameFilter };