@novu/js 3.7.0 → 3.8.0

package/dist/esm/{chunk-AIY4HF7H.mjs → chunk-EIKKISYN.mjs}

@@ -1,8 +1,8 @@
-import { buildSubscriber } from './chunk-KYYDDVBR.mjs';
+import { buildSubscriber } from './chunk-QOD7NZ77.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';
+import io from 'socket.io-client';
 
 // src/types.ts
 var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
@@ -66,10 +66,63 @@ 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 && filter1.seen === filter2.seen;
 };
+function checkNotificationDataFilter(notificationData, filterData) {
+  if (!filterData || Object.keys(filterData).length === 0) {
+    return true;
+  }
+  if (!notificationData) {
+    return false;
+  }
+  return Object.entries(filterData).every(([key, filterValue]) => {
+    const notifValue = notificationData[key];
+    if (notifValue === void 0 && filterValue !== void 0) {
+      return false;
+    }
+    if (Array.isArray(filterValue)) {
+      if (Array.isArray(notifValue)) {
+        if (filterValue.length !== notifValue.length) return false;
+        const sortedFilterValue = [...filterValue].sort();
+        const sortedNotifValue = [...notifValue].sort();
+        return sortedFilterValue.every((val, index) => val === sortedNotifValue[index]);
+      } else {
+        return filterValue.includes(notifValue);
+      }
+    } else {
+      return notifValue === filterValue;
+    }
+  });
+}
+function checkNotificationTagFilter(notificationTags, filterTags) {
+  if (!filterTags || filterTags.length === 0) {
+    return true;
+  }
+  if (!notificationTags || notificationTags.length === 0) {
+    return false;
+  }
+  return filterTags.some((tag) => notificationTags.includes(tag));
+}
+function checkBasicFilters(notification, filter) {
+  if (filter.read !== void 0 && notification.isRead !== filter.read) {
+    return false;
+  }
+  if (filter.seen !== void 0 && notification.isSeen !== filter.seen) {
+    return false;
+  }
+  if (filter.archived !== void 0 && notification.isArchived !== filter.archived) {
+    return false;
+  }
+  if (filter.snoozed !== void 0 && notification.isSnoozed !== filter.snoozed) {
+    return false;
+  }
+  return true;
+}
+function checkNotificationMatchesFilter(notification, filter) {
+  return checkBasicFilters(notification, filter) && checkNotificationTagFilter(notification.tags, filter.tags) && checkNotificationDataFilter(notification.data, filter.data);
+}
 
 // src/api/http-client.ts
 var DEFAULT_API_VERSION = "v1";
-var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.7.0"}`;
+var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.8.0"}`;
 var HttpClient = class {
   constructor(options = {}) {
     // Environment variable for local development that overrides the default API endpoint without affecting the Inbox DX
@@ -393,219 +446,6 @@ var NovuError = class extends Error {
   }
 };
 
-// src/base-module.ts
-var _callsQueue, _sessionError;
-var BaseModule = class {
-  constructor({
-    inboxServiceInstance,
-    eventEmitterInstance
-  }) {
-    __privateAdd(this, _callsQueue, []);
-    __privateAdd(this, _sessionError);
-    this._emitter = eventEmitterInstance;
-    this._inboxService = inboxServiceInstance;
-    this._emitter.on("session.initialize.resolved", ({ error, data }) => {
-      if (data) {
-        this.onSessionSuccess(data);
-        __privateGet(this, _callsQueue).forEach((_0) => __async(this, [_0], function* ({ fn, resolve }) {
-          resolve(yield fn());
-        }));
-        __privateSet(this, _callsQueue, []);
-      } else if (error) {
-        this.onSessionError(error);
-        __privateSet(this, _sessionError, error);
-        __privateGet(this, _callsQueue).forEach(({ resolve }) => {
-          resolve({ error: new NovuError("Failed to initialize session, please contact the support", error) });
-        });
-        __privateSet(this, _callsQueue, []);
-      }
-    });
-  }
-  onSessionSuccess(_) {
-  }
-  onSessionError(_) {
-  }
-  callWithSession(fn) {
-    return __async(this, null, function* () {
-      if (this._inboxService.isSessionInitialized) {
-        return fn();
-      }
-      if (__privateGet(this, _sessionError)) {
-        return Promise.resolve({
-          error: new NovuError("Failed to initialize session, please contact the support", __privateGet(this, _sessionError))
-        });
-      }
-      return new Promise((resolve, reject) => {
-        __privateGet(this, _callsQueue).push({ fn, resolve, reject });
-      });
-    });
-  }
-};
-_callsQueue = new WeakMap();
-_sessionError = new WeakMap();
-
-// src/notifications/notification.ts
-var _emitter, _inboxService;
-var Notification = class {
-  constructor(notification, emitter, inboxService) {
-    __privateAdd(this, _emitter);
-    __privateAdd(this, _inboxService);
-    __privateSet(this, _emitter, emitter);
-    __privateSet(this, _inboxService, inboxService);
-    this.id = notification.id;
-    this.subject = notification.subject;
-    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;
-    this.secondaryAction = notification.secondaryAction;
-    this.channelType = notification.channelType;
-    this.tags = notification.tags;
-    this.redirect = notification.redirect;
-    this.data = notification.data;
-    this.workflow = notification.workflow;
-  }
-  read() {
-    return read({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  unread() {
-    return unread({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  seen() {
-    return seen({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  archive() {
-    return archive({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  unarchive() {
-    return unarchive({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  snooze(snoozeUntil) {
-    return snooze({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this,
-        snoozeUntil
-      }
-    });
-  }
-  unsnooze() {
-    return unsnooze({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: { notification: this }
-    });
-  }
-  completePrimary() {
-    if (!this.primaryAction) {
-      throw new Error("Primary action is not available");
-    }
-    return completeAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "primary" /* PRIMARY */
-    });
-  }
-  completeSecondary() {
-    if (!this.primaryAction) {
-      throw new Error("Secondary action is not available");
-    }
-    return completeAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "secondary" /* SECONDARY */
-    });
-  }
-  revertPrimary() {
-    if (!this.primaryAction) {
-      throw new Error("Primary action is not available");
-    }
-    return revertAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "primary" /* PRIMARY */
-    });
-  }
-  revertSecondary() {
-    if (!this.primaryAction) {
-      throw new Error("Secondary action is not available");
-    }
-    return revertAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "secondary" /* SECONDARY */
-    });
-  }
-  on(eventName, listener) {
-    const cleanup = __privateGet(this, _emitter).on(eventName, listener);
-    return () => {
-      cleanup();
-    };
-  }
-  /**
-   * @deprecated
-   * Use the cleanup function returned by the "on" method instead.
-   */
-  off(eventName, listener) {
-    __privateGet(this, _emitter).off(eventName, listener);
-  }
-};
-_emitter = new WeakMap();
-_inboxService = new WeakMap();
-
 // src/notifications/helpers.ts
 var read = (_0) => __async(void 0, [_0], function* ({
   emitter,
@@ -1031,22 +871,235 @@ var archiveAllRead = (_0) => __async(void 0, [_0], function* ({
   }
 });
 
-// src/cache/in-memory-cache.ts
-var _cache;
-var InMemoryCache = class {
-  constructor() {
-    __privateAdd(this, _cache);
-    __privateSet(this, _cache, /* @__PURE__ */ new Map());
-  }
-  get(key) {
-    return __privateGet(this, _cache).get(key);
-  }
-  getValues() {
-    return Array.from(__privateGet(this, _cache).values());
-  }
-  entries() {
-    return Array.from(__privateGet(this, _cache).entries());
-  }
+// src/notifications/notification.ts
+var _emitter, _inboxService;
+var Notification = class {
+  constructor(notification, emitter, inboxService) {
+    __privateAdd(this, _emitter);
+    __privateAdd(this, _inboxService);
+    __privateSet(this, _emitter, emitter);
+    __privateSet(this, _inboxService, inboxService);
+    this.id = notification.id;
+    this.subject = notification.subject;
+    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;
+    this.secondaryAction = notification.secondaryAction;
+    this.channelType = notification.channelType;
+    this.tags = notification.tags;
+    this.redirect = notification.redirect;
+    this.data = notification.data;
+    this.workflow = notification.workflow;
+  }
+  read() {
+    return read({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      }
+    });
+  }
+  unread() {
+    return unread({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      }
+    });
+  }
+  seen() {
+    return seen({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      }
+    });
+  }
+  archive() {
+    return archive({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      }
+    });
+  }
+  unarchive() {
+    return unarchive({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      }
+    });
+  }
+  snooze(snoozeUntil) {
+    return snooze({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this,
+        snoozeUntil
+      }
+    });
+  }
+  unsnooze() {
+    return unsnooze({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: { notification: this }
+    });
+  }
+  completePrimary() {
+    if (!this.primaryAction) {
+      throw new Error("Primary action is not available");
+    }
+    return completeAction({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      },
+      actionType: "primary" /* PRIMARY */
+    });
+  }
+  completeSecondary() {
+    if (!this.primaryAction) {
+      throw new Error("Secondary action is not available");
+    }
+    return completeAction({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      },
+      actionType: "secondary" /* SECONDARY */
+    });
+  }
+  revertPrimary() {
+    if (!this.primaryAction) {
+      throw new Error("Primary action is not available");
+    }
+    return revertAction({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      },
+      actionType: "primary" /* PRIMARY */
+    });
+  }
+  revertSecondary() {
+    if (!this.primaryAction) {
+      throw new Error("Secondary action is not available");
+    }
+    return revertAction({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      },
+      actionType: "secondary" /* SECONDARY */
+    });
+  }
+  on(eventName, listener) {
+    const cleanup = __privateGet(this, _emitter).on(eventName, listener);
+    return () => {
+      cleanup();
+    };
+  }
+  /**
+   * @deprecated
+   * Use the cleanup function returned by the "on" method instead.
+   */
+  off(eventName, listener) {
+    __privateGet(this, _emitter).off(eventName, listener);
+  }
+};
+_emitter = new WeakMap();
+_inboxService = new WeakMap();
+
+// src/base-module.ts
+var _callsQueue, _sessionError;
+var BaseModule = class {
+  constructor({
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
+    __privateAdd(this, _callsQueue, []);
+    __privateAdd(this, _sessionError);
+    this._emitter = eventEmitterInstance;
+    this._inboxService = inboxServiceInstance;
+    this._emitter.on("session.initialize.resolved", ({ error, data }) => {
+      if (data) {
+        this.onSessionSuccess(data);
+        __privateGet(this, _callsQueue).forEach((_0) => __async(this, [_0], function* ({ fn, resolve }) {
+          resolve(yield fn());
+        }));
+        __privateSet(this, _callsQueue, []);
+      } else if (error) {
+        this.onSessionError(error);
+        __privateSet(this, _sessionError, error);
+        __privateGet(this, _callsQueue).forEach(({ resolve }) => {
+          resolve({ error: new NovuError("Failed to initialize session, please contact the support", error) });
+        });
+        __privateSet(this, _callsQueue, []);
+      }
+    });
+  }
+  onSessionSuccess(_) {
+  }
+  onSessionError(_) {
+  }
+  callWithSession(fn) {
+    return __async(this, null, function* () {
+      if (this._inboxService.isSessionInitialized) {
+        return fn();
+      }
+      if (__privateGet(this, _sessionError)) {
+        return Promise.resolve({
+          error: new NovuError("Failed to initialize session, please contact the support", __privateGet(this, _sessionError))
+        });
+      }
+      return new Promise((resolve, reject) => {
+        __privateGet(this, _callsQueue).push({ fn, resolve, reject });
+      });
+    });
+  }
+};
+_callsQueue = new WeakMap();
+_sessionError = new WeakMap();
+
+// src/cache/in-memory-cache.ts
+var _cache;
+var InMemoryCache = class {
+  constructor() {
+    __privateAdd(this, _cache);
+    __privateSet(this, _cache, /* @__PURE__ */ new Map());
+  }
+  get(key) {
+    return __privateGet(this, _cache).get(key);
+  }
+  getValues() {
+    return Array.from(__privateGet(this, _cache).values());
+  }
+  entries() {
+    return Array.from(__privateGet(this, _cache).entries());
+  }
   keys() {
     return Array.from(__privateGet(this, _cache).keys());
   }
@@ -1549,10 +1602,7 @@ var Notifications = class extends BaseModule {
     });
   }
   archiveAllRead() {
-    return __async(this, arguments, function* ({
-      tags,
-      data
-    } = {}) {
+    return __async(this, arguments, function* ({ tags, data } = {}) {
       return this.callWithSession(
         () => __async(this, null, function* () {
           return archiveAllRead({
@@ -1580,29 +1630,162 @@ var Notifications = class extends BaseModule {
 };
 _useCache = new WeakMap();
 
-// src/preferences/helpers.ts
-var updatePreference = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  cache,
-  useCache,
-  args
-}) {
-  var _a;
-  const { channels } = args;
-  const workflowId = "workflowId" in args ? args.workflowId : (_a = args.preference.workflow) == null ? void 0 : _a.id;
-  try {
-    emitter.emit("preference.update.pending", {
-      args,
-      data: "preference" in args ? new Preference(
-        __spreadProps(__spreadValues({}, args.preference), {
-          channels: __spreadValues(__spreadValues({}, args.preference.channels), channels)
-        }),
-        {
-          emitterInstance: emitter,
-          inboxServiceInstance: apiService,
-          cache,
-          useCache
+// src/cache/preferences-cache.ts
+var updateEvents2 = [
+  "preference.update.pending",
+  "preference.update.resolved",
+  "preferences.bulk_update.pending",
+  "preferences.bulk_update.resolved"
+];
+var excludeEmpty2 = ({ tags }) => Object.entries({ tags }).reduce((acc, [key, value]) => {
+  if (value === null || value === void 0 || Array.isArray(value) && value.length === 0) {
+    return acc;
+  }
+  acc[key] = value;
+  return acc;
+}, {});
+var getCacheKey2 = ({ tags }) => {
+  return JSON.stringify(excludeEmpty2({ tags }));
+};
+var _emitter3, _cache3;
+var PreferencesCache = class {
+  constructor({ emitterInstance }) {
+    __privateAdd(this, _emitter3);
+    __privateAdd(this, _cache3);
+    this.updatePreference = (key, data) => {
+      const preferences = __privateGet(this, _cache3).get(key);
+      if (!preferences) {
+        return false;
+      }
+      const index = preferences.findIndex(
+        (el) => {
+          var _a, _b;
+          return ((_a = el.workflow) == null ? void 0 : _a.id) === ((_b = data.workflow) == null ? void 0 : _b.id) || el.level === data.level && data.level === "global" /* GLOBAL */;
+        }
+      );
+      if (index === -1) {
+        return false;
+      }
+      const updatedPreferences = [...preferences];
+      updatedPreferences[index] = data;
+      __privateGet(this, _cache3).set(key, updatedPreferences);
+      return true;
+    };
+    this.handlePreferenceEvent = ({ data }) => {
+      if (!data) {
+        return;
+      }
+      const preferences = Array.isArray(data) ? data : [data];
+      const uniqueFilterKeys = /* @__PURE__ */ new Set();
+      __privateGet(this, _cache3).keys().forEach((key) => {
+        preferences.forEach((preference) => {
+          const hasUpdatedPreference = this.updatePreference(key, preference);
+          const updatedPreference = __privateGet(this, _cache3).get(key);
+          if (!hasUpdatedPreference || !updatedPreference) {
+            return;
+          }
+          uniqueFilterKeys.add(key);
+        });
+      });
+      uniqueFilterKeys.forEach((key) => {
+        var _a;
+        __privateGet(this, _emitter3).emit("preferences.list.updated", {
+          data: (_a = __privateGet(this, _cache3).get(key)) != null ? _a : []
+        });
+      });
+    };
+    __privateSet(this, _emitter3, emitterInstance);
+    updateEvents2.forEach((event) => {
+      __privateGet(this, _emitter3).on(event, this.handlePreferenceEvent);
+    });
+    __privateSet(this, _cache3, new InMemoryCache());
+  }
+  has(args) {
+    return __privateGet(this, _cache3).get(getCacheKey2(args)) !== void 0;
+  }
+  set(args, data) {
+    __privateGet(this, _cache3).set(getCacheKey2(args), data);
+  }
+  getAll(args) {
+    if (this.has(args)) {
+      return __privateGet(this, _cache3).get(getCacheKey2(args));
+    }
+  }
+  clearAll() {
+    __privateGet(this, _cache3).clear();
+  }
+};
+_emitter3 = new WeakMap();
+_cache3 = new WeakMap();
+
+// src/preferences/preference.ts
+var _emitter4, _apiService, _cache4, _useCache2;
+var Preference = class {
+  constructor(preference, {
+    emitterInstance,
+    inboxServiceInstance,
+    cache,
+    useCache
+  }) {
+    __privateAdd(this, _emitter4);
+    __privateAdd(this, _apiService);
+    __privateAdd(this, _cache4);
+    __privateAdd(this, _useCache2);
+    __privateSet(this, _emitter4, emitterInstance);
+    __privateSet(this, _apiService, inboxServiceInstance);
+    __privateSet(this, _cache4, cache);
+    __privateSet(this, _useCache2, useCache);
+    this.level = preference.level;
+    this.enabled = preference.enabled;
+    this.channels = preference.channels;
+    this.workflow = preference.workflow;
+  }
+  update({
+    channels,
+    channelPreferences
+  }) {
+    var _a;
+    return updatePreference({
+      emitter: __privateGet(this, _emitter4),
+      apiService: __privateGet(this, _apiService),
+      cache: __privateGet(this, _cache4),
+      useCache: __privateGet(this, _useCache2),
+      args: {
+        workflowId: (_a = this.workflow) == null ? void 0 : _a.id,
+        channels: channels || channelPreferences,
+        preference: this
+      }
+    });
+  }
+};
+_emitter4 = new WeakMap();
+_apiService = new WeakMap();
+_cache4 = new WeakMap();
+_useCache2 = new WeakMap();
+
+// src/preferences/helpers.ts
+var updatePreference = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  cache,
+  useCache,
+  args
+}) {
+  var _a;
+  const { channels } = args;
+  const workflowId = "workflowId" in args ? args.workflowId : (_a = args.preference.workflow) == null ? void 0 : _a.id;
+  try {
+    emitter.emit("preference.update.pending", {
+      args,
+      data: "preference" in args ? new Preference(
+        __spreadProps(__spreadValues({}, args.preference), {
+          channels: __spreadValues(__spreadValues({}, args.preference.channels), channels)
+        }),
+        {
+          emitterInstance: emitter,
+          inboxServiceInstance: apiService,
+          cache,
+          useCache
         }
       ) : void 0
     });
@@ -1715,139 +1898,6 @@ var optimisticUpdateWorkflowPreferences = ({
   });
 };
 
-// src/preferences/preference.ts
-var _emitter3, _apiService, _cache3, _useCache2;
-var Preference = class {
-  constructor(preference, {
-    emitterInstance,
-    inboxServiceInstance,
-    cache,
-    useCache
-  }) {
-    __privateAdd(this, _emitter3);
-    __privateAdd(this, _apiService);
-    __privateAdd(this, _cache3);
-    __privateAdd(this, _useCache2);
-    __privateSet(this, _emitter3, emitterInstance);
-    __privateSet(this, _apiService, inboxServiceInstance);
-    __privateSet(this, _cache3, cache);
-    __privateSet(this, _useCache2, useCache);
-    this.level = preference.level;
-    this.enabled = preference.enabled;
-    this.channels = preference.channels;
-    this.workflow = preference.workflow;
-  }
-  update({
-    channels,
-    channelPreferences
-  }) {
-    var _a;
-    return updatePreference({
-      emitter: __privateGet(this, _emitter3),
-      apiService: __privateGet(this, _apiService),
-      cache: __privateGet(this, _cache3),
-      useCache: __privateGet(this, _useCache2),
-      args: {
-        workflowId: (_a = this.workflow) == null ? void 0 : _a.id,
-        channels: channels || channelPreferences,
-        preference: this
-      }
-    });
-  }
-};
-_emitter3 = new WeakMap();
-_apiService = new WeakMap();
-_cache3 = new WeakMap();
-_useCache2 = new WeakMap();
-
-// src/cache/preferences-cache.ts
-var updateEvents2 = [
-  "preference.update.pending",
-  "preference.update.resolved",
-  "preferences.bulk_update.pending",
-  "preferences.bulk_update.resolved"
-];
-var excludeEmpty2 = ({ tags }) => Object.entries({ tags }).reduce((acc, [key, value]) => {
-  if (value === null || value === void 0 || Array.isArray(value) && value.length === 0) {
-    return acc;
-  }
-  acc[key] = value;
-  return acc;
-}, {});
-var getCacheKey2 = ({ tags }) => {
-  return JSON.stringify(excludeEmpty2({ tags }));
-};
-var _emitter4, _cache4;
-var PreferencesCache = class {
-  constructor({ emitterInstance }) {
-    __privateAdd(this, _emitter4);
-    __privateAdd(this, _cache4);
-    this.updatePreference = (key, data) => {
-      const preferences = __privateGet(this, _cache4).get(key);
-      if (!preferences) {
-        return false;
-      }
-      const index = preferences.findIndex(
-        (el) => {
-          var _a, _b;
-          return ((_a = el.workflow) == null ? void 0 : _a.id) === ((_b = data.workflow) == null ? void 0 : _b.id) || el.level === data.level && data.level === "global" /* GLOBAL */;
-        }
-      );
-      if (index === -1) {
-        return false;
-      }
-      const updatedPreferences = [...preferences];
-      updatedPreferences[index] = data;
-      __privateGet(this, _cache4).set(key, updatedPreferences);
-      return true;
-    };
-    this.handlePreferenceEvent = ({ data }) => {
-      if (!data) {
-        return;
-      }
-      const preferences = Array.isArray(data) ? data : [data];
-      const uniqueFilterKeys = /* @__PURE__ */ new Set();
-      __privateGet(this, _cache4).keys().forEach((key) => {
-        preferences.forEach((preference) => {
-          const hasUpdatedPreference = this.updatePreference(key, preference);
-          const updatedPreference = __privateGet(this, _cache4).get(key);
-          if (!hasUpdatedPreference || !updatedPreference) {
-            return;
-          }
-          uniqueFilterKeys.add(key);
-        });
-      });
-      uniqueFilterKeys.forEach((key) => {
-        var _a;
-        __privateGet(this, _emitter4).emit("preferences.list.updated", {
-          data: (_a = __privateGet(this, _cache4).get(key)) != null ? _a : []
-        });
-      });
-    };
-    __privateSet(this, _emitter4, emitterInstance);
-    updateEvents2.forEach((event) => {
-      __privateGet(this, _emitter4).on(event, this.handlePreferenceEvent);
-    });
-    __privateSet(this, _cache4, new InMemoryCache());
-  }
-  has(args) {
-    return __privateGet(this, _cache4).get(getCacheKey2(args)) !== void 0;
-  }
-  set(args, data) {
-    __privateGet(this, _cache4).set(getCacheKey2(args), data);
-  }
-  getAll(args) {
-    if (this.has(args)) {
-      return __privateGet(this, _cache4).get(getCacheKey2(args));
-    }
-  }
-  clearAll() {
-    __privateGet(this, _cache4).clear();
-  }
-};
-_emitter4 = new WeakMap();
-_cache4 = new WeakMap();
-
 // src/preferences/preferences.ts
 var _useCache3;
 var Preferences = class extends BaseModule {
@@ -2020,7 +2070,7 @@ var Session = class {
 _emitter5 = new WeakMap();
 _inboxService2 = new WeakMap();
 _options = new WeakMap();
-var PRODUCTION_SOCKET_URL = "https://ws.novu.co";
+var PRODUCTION_SOCKET_URL = "wss://socket.novu.co";
 var NOTIFICATION_RECEIVED = "notifications.notification_received";
 var UNSEEN_COUNT_CHANGED = "notifications.unseen_count_changed";
 var UNREAD_COUNT_CHANGED = "notifications.unread_count_changed";
@@ -2107,8 +2157,8 @@ var mapToNotification = ({
     workflow
   });
 };
-var _token, _emitter6, _socketIo, _socketUrl, _notificationReceived, _unseenCountChanged, _unreadCountChanged, _Socket_instances, initializeSocket_fn, handleConnectSocket_fn, handleDisconnectSocket_fn;
-var Socket = class extends BaseModule {
+var _token, _emitter6, _partySocket, _socketUrl, _notificationReceived, _unseenCountChanged, _unreadCountChanged, _handleMessage, _PartySocketClient_instances, initializeSocket_fn, handleConnectSocket_fn, handleDisconnectSocket_fn;
+var PartySocketClient = class extends BaseModule {
   constructor({
     socketUrl,
     inboxServiceInstance,
@@ -2118,25 +2168,62 @@ var Socket = class extends BaseModule {
       eventEmitterInstance,
       inboxServiceInstance
     });
-    __privateAdd(this, _Socket_instances);
+    __privateAdd(this, _PartySocketClient_instances);
     __privateAdd(this, _token);
     __privateAdd(this, _emitter6);
-    __privateAdd(this, _socketIo);
+    __privateAdd(this, _partySocket);
     __privateAdd(this, _socketUrl);
-    __privateAdd(this, _notificationReceived, ({ message }) => {
-      __privateGet(this, _emitter6).emit(NOTIFICATION_RECEIVED, {
-        result: new Notification(mapToNotification(message), __privateGet(this, _emitter6), this._inboxService)
-      });
+    __privateAdd(this, _notificationReceived, (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.event === "notification_received" /* RECEIVED */) {
+          __privateGet(this, _emitter6).emit(NOTIFICATION_RECEIVED, {
+            result: new Notification(mapToNotification(data.data.message), __privateGet(this, _emitter6), this._inboxService)
+          });
+        }
+      } catch (error) {
+        console.log("error", error);
+      }
     });
-    __privateAdd(this, _unseenCountChanged, ({ unseenCount }) => {
-      __privateGet(this, _emitter6).emit(UNSEEN_COUNT_CHANGED, {
-        result: unseenCount
-      });
+    __privateAdd(this, _unseenCountChanged, (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.event === "unseen_count_changed" /* UNSEEN */) {
+          __privateGet(this, _emitter6).emit(UNSEEN_COUNT_CHANGED, {
+            result: data.data.unseenCount
+          });
+        }
+      } catch (error) {
+      }
     });
-    __privateAdd(this, _unreadCountChanged, ({ unreadCount }) => {
-      __privateGet(this, _emitter6).emit(UNREAD_COUNT_CHANGED, {
-        result: unreadCount
-      });
+    __privateAdd(this, _unreadCountChanged, (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.event === "unread_count_changed" /* UNREAD */) {
+          __privateGet(this, _emitter6).emit(UNREAD_COUNT_CHANGED, {
+            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, _notificationReceived).call(this, event);
+            break;
+          case "unseen_count_changed" /* UNSEEN */:
+            __privateGet(this, _unseenCountChanged).call(this, event);
+            break;
+          case "unread_count_changed" /* UNREAD */:
+            __privateGet(this, _unreadCountChanged).call(this, event);
+            break;
+          default:
+        }
+      } catch (error) {
+      }
     });
     __privateSet(this, _emitter6, eventEmitterInstance);
     __privateSet(this, _socketUrl, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL);
@@ -2150,61 +2237,55 @@ var Socket = class extends BaseModule {
   connect() {
     return __async(this, null, function* () {
       if (__privateGet(this, _token)) {
-        return __privateMethod(this, _Socket_instances, handleConnectSocket_fn).call(this);
+        return __privateMethod(this, _PartySocketClient_instances, handleConnectSocket_fn).call(this);
       }
-      return this.callWithSession(__privateMethod(this, _Socket_instances, handleConnectSocket_fn).bind(this));
+      return this.callWithSession(__privateMethod(this, _PartySocketClient_instances, handleConnectSocket_fn).bind(this));
     });
   }
   disconnect() {
     return __async(this, null, function* () {
-      if (__privateGet(this, _socketIo)) {
-        return __privateMethod(this, _Socket_instances, handleDisconnectSocket_fn).call(this);
+      if (__privateGet(this, _partySocket)) {
+        return __privateMethod(this, _PartySocketClient_instances, handleDisconnectSocket_fn).call(this);
       }
-      return this.callWithSession(__privateMethod(this, _Socket_instances, handleDisconnectSocket_fn).bind(this));
+      return this.callWithSession(__privateMethod(this, _PartySocketClient_instances, handleDisconnectSocket_fn).bind(this));
     });
   }
 };
 _token = new WeakMap();
 _emitter6 = new WeakMap();
-_socketIo = new WeakMap();
+_partySocket = new WeakMap();
 _socketUrl = new WeakMap();
 _notificationReceived = new WeakMap();
 _unseenCountChanged = new WeakMap();
 _unreadCountChanged = new WeakMap();
-_Socket_instances = new WeakSet();
+_handleMessage = new WeakMap();
+_PartySocketClient_instances = new WeakSet();
 initializeSocket_fn = function() {
   return __async(this, null, function* () {
-    var _a, _b, _c;
-    if (!!__privateGet(this, _socketIo)) {
+    if (__privateGet(this, _partySocket)) {
       return;
     }
     const args = { socketUrl: __privateGet(this, _socketUrl) };
     __privateGet(this, _emitter6).emit("socket.connect.pending", { args });
-    __privateSet(this, _socketIo, io(__privateGet(this, _socketUrl), {
-      reconnectionDelayMax: 1e4,
-      transports: ["websocket"],
-      query: {
-        token: `${__privateGet(this, _token)}`
-      }
-    }));
-    __privateGet(this, _socketIo).on("connect", () => {
+    const url = new URL(__privateGet(this, _socketUrl));
+    url.searchParams.set("token", __privateGet(this, _token));
+    __privateSet(this, _partySocket, new WebSocket(url.toString()));
+    __privateGet(this, _partySocket).addEventListener("open", () => {
       __privateGet(this, _emitter6).emit("socket.connect.resolved", { args });
     });
-    __privateGet(this, _socketIo).on("connect_error", (error) => {
+    __privateGet(this, _partySocket).addEventListener("error", (error) => {
       __privateGet(this, _emitter6).emit("socket.connect.resolved", { args, error });
     });
-    (_a = __privateGet(this, _socketIo)) == null ? void 0 : _a.on("notification_received" /* RECEIVED */, __privateGet(this, _notificationReceived));
-    (_b = __privateGet(this, _socketIo)) == null ? void 0 : _b.on("unseen_count_changed" /* UNSEEN */, __privateGet(this, _unseenCountChanged));
-    (_c = __privateGet(this, _socketIo)) == null ? void 0 : _c.on("unread_count_changed" /* UNREAD */, __privateGet(this, _unreadCountChanged));
+    __privateGet(this, _partySocket).addEventListener("message", __privateGet(this, _handleMessage));
   });
 };
 handleConnectSocket_fn = function() {
   return __async(this, null, function* () {
     try {
-      yield __privateMethod(this, _Socket_instances, initializeSocket_fn).call(this);
+      yield __privateMethod(this, _PartySocketClient_instances, initializeSocket_fn).call(this);
       return {};
     } catch (error) {
-      return { error: new NovuError("Failed to initialize the socket", error) };
+      return { error: new NovuError("Failed to initialize the PartySocket", error) };
     }
   });
 };
@@ -2212,15 +2293,15 @@ handleDisconnectSocket_fn = function() {
   return __async(this, null, function* () {
     var _a;
     try {
-      (_a = __privateGet(this, _socketIo)) == null ? void 0 : _a.disconnect();
-      __privateSet(this, _socketIo, void 0);
+      (_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 socket", error) };
+      return { error: new NovuError("Failed to disconnect from the PartySocket", error) };
     }
   });
 };
-var PRODUCTION_SOCKET_URL2 = "wss://socket.novu.co";
+var PRODUCTION_SOCKET_URL2 = "https://ws.novu.co";
 var NOTIFICATION_RECEIVED2 = "notifications.notification_received";
 var UNSEEN_COUNT_CHANGED2 = "notifications.unseen_count_changed";
 var UNREAD_COUNT_CHANGED2 = "notifications.unread_count_changed";
@@ -2307,8 +2388,8 @@ var mapToNotification2 = ({
     workflow
   });
 };
-var _token2, _emitter7, _partySocket, _socketUrl2, _notificationReceived2, _unseenCountChanged2, _unreadCountChanged2, _handleMessage, _PartySocketClient_instances, initializeSocket_fn2, handleConnectSocket_fn2, handleDisconnectSocket_fn2;
-var PartySocketClient = class extends BaseModule {
+var _token2, _emitter7, _socketIo, _socketUrl2, _notificationReceived2, _unseenCountChanged2, _unreadCountChanged2, _Socket_instances, initializeSocket_fn2, handleConnectSocket_fn2, handleDisconnectSocket_fn2;
+var Socket = class extends BaseModule {
   constructor({
     socketUrl,
     inboxServiceInstance,
@@ -2318,62 +2399,25 @@ var PartySocketClient = class extends BaseModule {
       eventEmitterInstance,
       inboxServiceInstance
     });
-    __privateAdd(this, _PartySocketClient_instances);
+    __privateAdd(this, _Socket_instances);
     __privateAdd(this, _token2);
     __privateAdd(this, _emitter7);
-    __privateAdd(this, _partySocket);
+    __privateAdd(this, _socketIo);
     __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, _notificationReceived2, ({ message }) => {
+      __privateGet(this, _emitter7).emit(NOTIFICATION_RECEIVED2, {
+        result: new Notification(mapToNotification2(message), __privateGet(this, _emitter7), this._inboxService)
+      });
     });
-    __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, _unseenCountChanged2, ({ unseenCount }) => {
+      __privateGet(this, _emitter7).emit(UNSEEN_COUNT_CHANGED2, {
+        result: unseenCount
+      });
     });
-    __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) {
-      }
+    __privateAdd(this, _unreadCountChanged2, ({ unreadCount }) => {
+      __privateGet(this, _emitter7).emit(UNREAD_COUNT_CHANGED2, {
+        result: unreadCount
+      });
     });
     __privateSet(this, _emitter7, eventEmitterInstance);
     __privateSet(this, _socketUrl2, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL2);
@@ -2387,55 +2431,61 @@ var PartySocketClient = class extends BaseModule {
   connect() {
     return __async(this, null, function* () {
       if (__privateGet(this, _token2)) {
-        return __privateMethod(this, _PartySocketClient_instances, handleConnectSocket_fn2).call(this);
+        return __privateMethod(this, _Socket_instances, handleConnectSocket_fn2).call(this);
       }
-      return this.callWithSession(__privateMethod(this, _PartySocketClient_instances, handleConnectSocket_fn2).bind(this));
+      return this.callWithSession(__privateMethod(this, _Socket_instances, handleConnectSocket_fn2).bind(this));
     });
   }
   disconnect() {
     return __async(this, null, function* () {
-      if (__privateGet(this, _partySocket)) {
-        return __privateMethod(this, _PartySocketClient_instances, handleDisconnectSocket_fn2).call(this);
+      if (__privateGet(this, _socketIo)) {
+        return __privateMethod(this, _Socket_instances, handleDisconnectSocket_fn2).call(this);
       }
-      return this.callWithSession(__privateMethod(this, _PartySocketClient_instances, handleDisconnectSocket_fn2).bind(this));
+      return this.callWithSession(__privateMethod(this, _Socket_instances, handleDisconnectSocket_fn2).bind(this));
     });
   }
 };
 _token2 = new WeakMap();
 _emitter7 = new WeakMap();
-_partySocket = new WeakMap();
+_socketIo = new WeakMap();
 _socketUrl2 = new WeakMap();
 _notificationReceived2 = new WeakMap();
 _unseenCountChanged2 = new WeakMap();
 _unreadCountChanged2 = new WeakMap();
-_handleMessage = new WeakMap();
-_PartySocketClient_instances = new WeakSet();
+_Socket_instances = new WeakSet();
 initializeSocket_fn2 = function() {
   return __async(this, null, function* () {
-    if (__privateGet(this, _partySocket)) {
+    var _a, _b, _c;
+    if (__privateGet(this, _socketIo)) {
       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", () => {
+    __privateSet(this, _socketIo, io(__privateGet(this, _socketUrl2), {
+      reconnectionDelayMax: 1e4,
+      transports: ["websocket"],
+      query: {
+        token: `${__privateGet(this, _token2)}`
+      }
+    }));
+    __privateGet(this, _socketIo).on("connect", () => {
       __privateGet(this, _emitter7).emit("socket.connect.resolved", { args });
     });
-    __privateGet(this, _partySocket).addEventListener("error", (error) => {
+    __privateGet(this, _socketIo).on("connect_error", (error) => {
       __privateGet(this, _emitter7).emit("socket.connect.resolved", { args, error });
     });
-    __privateGet(this, _partySocket).addEventListener("message", __privateGet(this, _handleMessage));
+    (_a = __privateGet(this, _socketIo)) == null ? void 0 : _a.on("notification_received" /* RECEIVED */, __privateGet(this, _notificationReceived2));
+    (_b = __privateGet(this, _socketIo)) == null ? void 0 : _b.on("unseen_count_changed" /* UNSEEN */, __privateGet(this, _unseenCountChanged2));
+    (_c = __privateGet(this, _socketIo)) == null ? void 0 : _c.on("unread_count_changed" /* UNREAD */, __privateGet(this, _unreadCountChanged2));
   });
 };
 handleConnectSocket_fn2 = function() {
   return __async(this, null, function* () {
     try {
-      yield __privateMethod(this, _PartySocketClient_instances, initializeSocket_fn2).call(this);
+      yield __privateMethod(this, _Socket_instances, initializeSocket_fn2).call(this);
       return {};
     } catch (error) {
-      return { error: new NovuError("Failed to initialize the PartySocket", error) };
+      return { error: new NovuError("Failed to initialize the socket", error) };
     }
   });
 };
@@ -2443,11 +2493,11 @@ 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);
+      (_a = __privateGet(this, _socketIo)) == null ? void 0 : _a.disconnect();
+      __privateSet(this, _socketIo, void 0);
       return {};
     } catch (error) {
-      return { error: new NovuError("Failed to disconnect from the PartySocket", error) };
+      return { error: new NovuError("Failed to disconnect from the socket", error) };
     }
   });
 };
@@ -2455,17 +2505,17 @@ handleDisconnectSocket_fn2 = function() {
 // src/ws/socket-factory.ts
 var PARTY_SOCKET_URLS = [
   "wss://eu.socket.novu.co",
-  PRODUCTION_SOCKET_URL2,
+  PRODUCTION_SOCKET_URL,
   "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://ws.novu.co": PRODUCTION_SOCKET_URL,
   "https://dev.ws.novu.co": "wss://socket.novu-staging.co"
 };
 function transformSocketUrl(socketUrl) {
-  if (!socketUrl) return PRODUCTION_SOCKET_URL2;
+  if (!socketUrl) return PRODUCTION_SOCKET_URL;
   return URL_TRANSFORMATIONS[socketUrl] || socketUrl;
 }
 function shouldUsePartySocket(socketUrl) {
@@ -2566,4 +2616,4 @@ _emitter8 = new WeakMap();
 _session = new WeakMap();
 _inboxService3 = new WeakMap();
 
-export { ChannelType, DEFAULT_API_VERSION, NotificationStatus, Novu, PreferenceLevel, WebSocketEvent, areTagsEqual, isBrowser, isSameFilter };
+export { ChannelType, DEFAULT_API_VERSION, NotificationStatus, Novu, PreferenceLevel, WebSocketEvent, areTagsEqual, checkNotificationDataFilter, checkNotificationMatchesFilter, checkNotificationTagFilter, isBrowser, isSameFilter };