@knocklabs/client 0.18.0 → 0.18.2

package/dist/esm/clients/feed/feed.mjs

@@ -1,6 +1,6 @@
 var p = Object.defineProperty;
-var g = (u, e, t) => e in u ? p(u, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : u[e] = t;
-var d = (u, e, t) => g(u, typeof e != "symbol" ? e + "" : e, t);
+var g = (u, t, e) => t in u ? p(u, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : u[t] = e;
+var c = (u, t, e) => g(u, typeof t != "symbol" ? t + "" : t, e);
 import k from "eventemitter2";
 import { nanoid as _ } from "nanoid";
 import { isValidUuid as v } from "../../helpers.mjs";
@@ -8,46 +8,46 @@ import { isRequestInFlight as S, NetworkStatus as m } from "../../networkStatus.
 import { SocketEventType as y } from "./socket-manager.mjs";
 import b from "./store.mjs";
 import { mergeDateRangeParams as f, getFormattedTriggerData as I } from "./utils.mjs";
-const U = {
+const C = {
   archived: "exclude"
-}, C = 2e3, w = "client_";
+}, U = 2e3, w = "client_";
 class P {
-  constructor(e, t, s, a) {
-    d(this, "defaultOptions");
-    d(this, "referenceId");
-    d(this, "unsubscribeFromSocketEvents");
-    d(this, "socketManager");
-    d(this, "userFeedId");
-    d(this, "broadcaster");
-    d(this, "broadcastChannel");
-    d(this, "disconnectTimer", null);
-    d(this, "hasSubscribedToRealTimeUpdates", !1);
-    d(this, "visibilityChangeHandler", () => {
+  constructor(t, e, s, n) {
+    c(this, "defaultOptions");
+    c(this, "referenceId");
+    c(this, "unsubscribeFromSocketEvents");
+    c(this, "socketManager");
+    c(this, "userFeedId");
+    c(this, "broadcaster");
+    c(this, "broadcastChannel");
+    c(this, "disconnectTimer", null);
+    c(this, "hasSubscribedToRealTimeUpdates", !1);
+    c(this, "visibilityChangeHandler", () => {
     });
-    d(this, "visibilityChangeListenerConnected", !1);
+    c(this, "visibilityChangeListenerConnected", !1);
     // The raw store instance, used for binding in React and other environments
-    d(this, "store");
-    this.knock = e, this.feedId = t, (!t || !v(t)) && this.knock.log(
+    c(this, "store");
+    this.knock = t, this.feedId = e, (!e || !v(e)) && this.knock.log(
       "[Feed] Invalid or missing feedId provided to the Feed constructor. The feed should be a UUID of an in-app feed channel (`in_app_feed`) found in the Knock dashboard. Please provide a valid feedId to the Feed constructor.",
       !0
-    ), this.feedId = t, this.userFeedId = this.buildUserFeedId(), this.referenceId = w + _(), this.socketManager = a, this.store = b(), this.broadcaster = new k({ wildcard: !0, delimiter: "." }), this.defaultOptions = {
-      ...U,
+    ), this.feedId = e, this.userFeedId = this.buildUserFeedId(), this.referenceId = w + _(), this.socketManager = n, this.store = b(), this.broadcaster = new k({ wildcard: !0, delimiter: "." }), this.defaultOptions = {
+      ...C,
       ...f(s)
-    }, this.knock.log(`[Feed] Initialized a feed on channel ${t}`), this.initializeRealtimeConnection(), this.setupBroadcastChannel();
+    }, this.knock.log(`[Feed] Initialized a feed on channel ${e}`), this.initializeRealtimeConnection(), this.setupBroadcastChannel();
   }
   /**
    * Used to reinitialize a current feed instance, which is useful when reauthenticating users
    */
-  reinitialize(e) {
-    this.socketManager = e, this.userFeedId = this.buildUserFeedId(), this.initializeRealtimeConnection(), this.setupBroadcastChannel();
+  reinitialize(t) {
+    this.socketManager = t, this.userFeedId = this.buildUserFeedId(), this.initializeRealtimeConnection(), this.setupBroadcastChannel();
   }
   /**
    * Cleans up a feed instance by destroying the store and disconnecting
    * an open socket connection.
    */
   teardown() {
-    var e;
-    this.knock.log("[Feed] Tearing down feed instance"), (e = this.socketManager) == null || e.leave(this), this.tearDownVisibilityListeners(), this.disconnectTimer && (clearTimeout(this.disconnectTimer), this.disconnectTimer = null), this.broadcastChannel && this.broadcastChannel.close();
+    var t;
+    this.knock.log("[Feed] Tearing down feed instance"), (t = this.socketManager) == null || t.leave(this), this.tearDownVisibilityListeners(), this.disconnectTimer && (clearTimeout(this.disconnectTimer), this.disconnectTimer = null), this.broadcastChannel && this.broadcastChannel.close();
   }
   /** Tears down an instance and removes it entirely from the feed manager */
   dispose() {
@@ -58,102 +58,102 @@ class P {
     current ApiClient instance if the socket is not already connected.
   */
   listenForUpdates() {
-    var e;
+    var t;
     if (this.knock.log("[Feed] Connecting to real-time service"), this.hasSubscribedToRealTimeUpdates = !0, !this.knock.isAuthenticated()) {
       this.knock.log(
         "[Feed] User is not authenticated, skipping listening for updates"
       );
       return;
     }
-    this.unsubscribeFromSocketEvents = (e = this.socketManager) == null ? void 0 : e.join(this);
+    this.unsubscribeFromSocketEvents = (t = this.socketManager) == null ? void 0 : t.join(this);
   }
   /* Binds a handler to be invoked when event occurs */
-  on(e, t) {
-    this.broadcaster.on(e, t);
+  on(t, e) {
+    this.broadcaster.on(t, e);
   }
-  off(e, t) {
-    this.broadcaster.off(e, t);
+  off(t, e) {
+    this.broadcaster.off(t, e);
   }
   getState() {
     return this.store.getState();
   }
-  async markAsSeen(e) {
-    const t = (/* @__PURE__ */ new Date()).toISOString();
+  async markAsSeen(t) {
+    const e = (/* @__PURE__ */ new Date()).toISOString();
     return this.optimisticallyPerformStatusUpdate(
-      e,
+      t,
       "seen",
-      { seen_at: t },
+      { seen_at: e },
       "unseen_count"
-    ), this.makeStatusUpdate(e, "seen");
+    ), this.makeStatusUpdate(t, "seen");
   }
   async markAllAsSeen() {
-    const { metadata: e, items: t, ...s } = this.store.getState();
+    const { metadata: t, items: e, ...s } = this.store.getState();
     if (this.defaultOptions.status === "unseen")
       s.resetStore({
-        ...e,
+        ...t,
         total_count: 0,
         unseen_count: 0
       });
     else {
-      s.setMetadata({ ...e, unseen_count: 0 });
-      const i = { seen_at: (/* @__PURE__ */ new Date()).toISOString() }, n = t.map((o) => o.id);
-      s.setItemAttrs(n, i);
+      s.setMetadata({ ...t, unseen_count: 0 });
+      const a = { seen_at: (/* @__PURE__ */ new Date()).toISOString() }, i = e.map((d) => d.id);
+      s.setItemAttrs(i, a);
     }
-    const r = await this.makeBulkStatusUpdate("seen");
-    return this.emitEvent("all_seen", t), r;
+    const o = await this.makeBulkStatusUpdate("seen");
+    return this.emitEvent("all_seen", e), o;
   }
-  async markAsUnseen(e) {
+  async markAsUnseen(t) {
     return this.optimisticallyPerformStatusUpdate(
-      e,
+      t,
       "unseen",
       { seen_at: null },
       "unseen_count"
-    ), this.makeStatusUpdate(e, "unseen");
+    ), this.makeStatusUpdate(t, "unseen");
   }
-  async markAsRead(e) {
-    const t = (/* @__PURE__ */ new Date()).toISOString();
+  async markAsRead(t) {
+    const e = (/* @__PURE__ */ new Date()).toISOString();
     return this.optimisticallyPerformStatusUpdate(
-      e,
+      t,
       "read",
-      { read_at: t },
+      { read_at: e },
       "unread_count"
-    ), this.makeStatusUpdate(e, "read");
+    ), this.makeStatusUpdate(t, "read");
   }
   async markAllAsRead() {
-    const { metadata: e, items: t, ...s } = this.store.getState();
+    const { metadata: t, items: e, ...s } = this.store.getState();
     if (this.defaultOptions.status === "unread")
       s.resetStore({
-        ...e,
+        ...t,
         total_count: 0,
         unread_count: 0
       });
     else {
-      s.setMetadata({ ...e, unread_count: 0 });
-      const i = { read_at: (/* @__PURE__ */ new Date()).toISOString() }, n = t.map((o) => o.id);
-      s.setItemAttrs(n, i);
+      s.setMetadata({ ...t, unread_count: 0 });
+      const a = { read_at: (/* @__PURE__ */ new Date()).toISOString() }, i = e.map((d) => d.id);
+      s.setItemAttrs(i, a);
     }
-    const r = await this.makeBulkStatusUpdate("read");
-    return this.emitEvent("all_read", t), r;
+    const o = await this.makeBulkStatusUpdate("read");
+    return this.emitEvent("all_read", e), o;
   }
-  async markAsUnread(e) {
+  async markAsUnread(t) {
     return this.optimisticallyPerformStatusUpdate(
-      e,
+      t,
       "unread",
       { read_at: null },
       "unread_count"
-    ), this.makeStatusUpdate(e, "unread");
+    ), this.makeStatusUpdate(t, "unread");
   }
-  async markAsInteracted(e, t) {
+  async markAsInteracted(t, e) {
     const s = (/* @__PURE__ */ new Date()).toISOString();
     return this.optimisticallyPerformStatusUpdate(
-      e,
+      t,
       "interacted",
       {
         read_at: s,
         interacted_at: s
       },
       "unread_count"
-    ), this.makeStatusUpdate(e, "interacted", t);
+    ), this.makeStatusUpdate(t, "interacted", e);
   }
   /*
     Marking one or more items as archived should:
@@ -163,147 +163,166 @@ class P {
   
     TODO: how do we handle rollbacks?
     */
-  async markAsArchived(e) {
-    const t = this.store.getState(), s = this.defaultOptions.archived === "exclude", a = Array.isArray(e) ? e : [e], r = a.map((i) => i.id);
+  async markAsArchived(t) {
+    const e = this.store.getState(), s = this.defaultOptions.archived === "exclude", n = Array.isArray(t) ? t : [t], o = n.map((a) => a.id);
     if (s) {
-      const i = a.filter((c) => !c.seen_at).length, n = a.filter((c) => !c.read_at).length, o = {
-        ...t.metadata,
+      const a = n.filter((r) => !r.seen_at).length, i = n.filter((r) => !r.read_at).length, d = {
+        ...e.metadata,
         // Ensure that the counts don't ever go below 0 on archiving where the client state
         // gets out of sync with the server state
-        total_count: Math.max(0, t.metadata.total_count - a.length),
-        unseen_count: Math.max(0, t.metadata.unseen_count - i),
-        unread_count: Math.max(0, t.metadata.unread_count - n)
-      }, l = t.items.filter(
-        (c) => !r.includes(c.id)
+        total_count: Math.max(0, e.metadata.total_count - n.length),
+        unseen_count: Math.max(0, e.metadata.unseen_count - a),
+        unread_count: Math.max(0, e.metadata.unread_count - i)
+      }, l = e.items.filter(
+        (r) => !o.includes(r.id)
       );
-      t.setResult({
+      e.setResult({
         entries: l,
-        meta: o,
-        page_info: t.pageInfo
+        meta: d,
+        page_info: e.pageInfo
       });
     } else
-      t.setItemAttrs(r, { archived_at: (/* @__PURE__ */ new Date()).toISOString() });
-    return this.makeStatusUpdate(e, "archived");
+      e.setItemAttrs(o, { archived_at: (/* @__PURE__ */ new Date()).toISOString() });
+    return this.makeStatusUpdate(t, "archived");
   }
   async markAllAsArchived() {
-    const { items: e, ...t } = this.store.getState();
+    const { items: t, ...e } = this.store.getState();
     if (this.defaultOptions.archived === "exclude")
-      t.resetStore();
+      e.resetStore();
     else {
-      const r = e.map((i) => i.id);
-      t.setItemAttrs(r, { archived_at: (/* @__PURE__ */ new Date()).toISOString() });
+      const o = t.map((a) => a.id);
+      e.setItemAttrs(o, { archived_at: (/* @__PURE__ */ new Date()).toISOString() });
     }
-    const a = await this.makeBulkStatusUpdate("archive");
-    return this.emitEvent("all_archived", e), a;
+    const n = await this.makeBulkStatusUpdate("archive");
+    return this.emitEvent("all_archived", t), n;
   }
   async markAllReadAsArchived() {
-    const { items: e, ...t } = this.store.getState(), a = e.filter((n) => n.read_at === null).map((n) => n.id);
-    if (t.setItemAttrs(a, {
+    const { items: t, ...e } = this.store.getState(), n = t.filter((i) => i.read_at === null).map((i) => i.id);
+    if (e.setItemAttrs(n, {
       archived_at: (/* @__PURE__ */ new Date()).toISOString()
     }), this.defaultOptions.archived === "exclude") {
-      const n = e.filter((l) => !a.includes(l.id)), o = {
-        ...t.metadata,
-        total_count: n.length,
+      const i = t.filter((l) => !n.includes(l.id)), d = {
+        ...e.metadata,
+        total_count: i.length,
         unread_count: 0
       };
-      t.setResult({
-        entries: n,
-        meta: o,
-        page_info: t.pageInfo
+      e.setResult({
+        entries: i,
+        meta: d,
+        page_info: e.pageInfo
       });
     }
     return await this.makeBulkStatusUpdate("archive");
   }
-  async markAsUnarchived(e) {
-    return this.optimisticallyPerformStatusUpdate(e, "unarchived", {
-      archived_at: null
-    }), this.makeStatusUpdate(e, "unarchived");
+  async markAsUnarchived(t) {
+    const e = this.store.getState(), s = Array.isArray(t) ? t : [t], n = s.map((a) => a.id);
+    if (this.defaultOptions.archived === "only") {
+      const a = s.filter((r) => !r.seen_at).length, i = s.filter((r) => !r.read_at).length, d = {
+        ...e.metadata,
+        // Ensure that the counts don't ever go below 0 on unarchiving where the client state
+        // gets out of sync with the server state
+        total_count: Math.max(0, e.metadata.total_count - s.length),
+        unseen_count: Math.max(0, e.metadata.unseen_count - a),
+        unread_count: Math.max(0, e.metadata.unread_count - i)
+      }, l = e.items.filter(
+        (r) => !n.includes(r.id)
+      );
+      e.setResult({
+        entries: l,
+        meta: d,
+        page_info: e.pageInfo
+      });
+    } else
+      this.optimisticallyPerformStatusUpdate(t, "unarchived", {
+        archived_at: null
+      });
+    return this.makeStatusUpdate(t, "unarchived");
   }
   /* Fetches the feed content, appending it to the store */
-  async fetch(e = {}) {
-    const { networkStatus: t, ...s } = this.store.getState();
+  async fetch(t = {}) {
+    const { networkStatus: e, ...s } = this.store.getState();
     if (!this.knock.isAuthenticated()) {
       this.knock.log("[Feed] User is not authenticated, skipping fetch");
       return;
     }
-    if (S(t)) {
+    if (S(e)) {
       this.knock.log("[Feed] Request is in flight, skipping fetch");
       return;
     }
-    s.setNetworkStatus(e.__loadingType ?? m.loading);
-    const a = I({
+    s.setNetworkStatus(t.__loadingType ?? m.loading);
+    const n = I({
       ...this.defaultOptions,
-      ...e
-    }), r = {
+      ...t
+    }), o = {
       ...this.defaultOptions,
-      ...f(e),
-      trigger_data: a,
+      ...f(t),
+      trigger_data: n,
       // Unset options that should not be sent to the API
       __loadingType: void 0,
       __fetchSource: void 0,
       __experimentalCrossBrowserUpdates: void 0,
       auto_manage_socket_connection: void 0,
       auto_manage_socket_connection_delay: void 0
-    }, i = await this.knock.client().makeRequest({
+    }, a = await this.knock.client().makeRequest({
       method: "GET",
       url: `/v1/users/${this.knock.userId}/feeds/${this.feedId}`,
-      params: r
+      params: o
     });
-    if (i.statusCode === "error" || !i.body)
+    if (a.statusCode === "error" || !a.body)
       return s.setNetworkStatus(m.error), {
-        status: i.statusCode,
-        data: i.error || i.body
+        status: a.statusCode,
+        data: a.error || a.body
       };
-    const n = {
-      entries: i.body.entries,
-      meta: i.body.meta,
-      page_info: i.body.page_info
+    const i = {
+      entries: a.body.entries,
+      meta: a.body.meta,
+      page_info: a.body.page_info
     };
-    if (e.before) {
-      const c = { shouldSetPage: !1, shouldAppend: !0 };
-      s.setResult(n, c);
-    } else if (e.after) {
-      const c = { shouldSetPage: !0, shouldAppend: !0 };
-      s.setResult(n, c);
+    if (t.before) {
+      const r = { shouldSetPage: !1, shouldAppend: !0 };
+      s.setResult(i, r);
+    } else if (t.after) {
+      const r = { shouldSetPage: !0, shouldAppend: !0 };
+      s.setResult(i, r);
     } else
-      s.setResult(n);
-    this.broadcast("messages.new", n);
-    const o = e.__fetchSource === "socket" ? "items.received.realtime" : "items.received.page", l = {
-      items: n.entries,
-      metadata: n.meta,
-      event: o
+      s.setResult(i);
+    this.broadcast("messages.new", i);
+    const d = t.__fetchSource === "socket" ? "items.received.realtime" : "items.received.page", l = {
+      items: i.entries,
+      metadata: i.meta,
+      event: d
     };
-    return this.broadcast(l.event, l), { data: n, status: i.statusCode };
+    return this.broadcast(l.event, l), { data: i, status: a.statusCode };
   }
-  async fetchNextPage(e = {}) {
-    const { pageInfo: t } = this.store.getState();
-    t.after && this.fetch({
-      ...e,
-      after: t.after,
+  async fetchNextPage(t = {}) {
+    const { pageInfo: e } = this.store.getState();
+    e.after && this.fetch({
+      ...t,
+      after: e.after,
       __loadingType: m.fetchMore
     });
   }
   get socketChannelTopic() {
     return `feeds:${this.userFeedId}`;
   }
-  broadcast(e, t) {
-    this.broadcaster.emit(e, t);
+  broadcast(t, e) {
+    this.broadcaster.emit(t, e);
   }
   // Invoked when a new real-time message comes in from the socket
-  async onNewMessageReceived({ data: e }) {
-    var i;
+  async onNewMessageReceived({ data: t }) {
+    var a;
     this.knock.log("[Feed] Received new real-time message");
-    const { items: t, ...s } = this.store.getState(), a = t[0], r = (i = e[this.referenceId]) == null ? void 0 : i.metadata;
-    r && s.setMetadata(r), this.fetch({ before: a == null ? void 0 : a.__cursor, __fetchSource: "socket" });
+    const { items: e, ...s } = this.store.getState(), n = e[0], o = (a = t[this.referenceId]) == null ? void 0 : a.metadata;
+    o && s.setMetadata(o), this.fetch({ before: n == null ? void 0 : n.__cursor, __fetchSource: "socket" });
   }
   buildUserFeedId() {
     return `${this.feedId}:${this.knock.userId}`;
   }
-  optimisticallyPerformStatusUpdate(e, t, s, a) {
-    const r = this.store.getState(), i = Array.isArray(e) ? e : [e], n = i.map((o) => o.id);
-    if (a) {
-      const { metadata: o } = r, l = i.filter((h) => {
-        switch (t) {
+  optimisticallyPerformStatusUpdate(t, e, s, n) {
+    const o = this.store.getState(), a = Array.isArray(t) ? t : [t], i = a.map((d) => d.id);
+    if (n) {
+      const { metadata: d } = o, l = a.filter((h) => {
+        switch (e) {
           case "seen":
             return h.seen_at === null;
           case "unseen":
@@ -316,24 +335,24 @@ class P {
           default:
             return !0;
         }
-      }), c = t.startsWith("un") ? l.length : -l.length;
-      r.setMetadata({
-        ...o,
-        [a]: Math.max(0, o[a] + c)
+      }), r = e.startsWith("un") ? l.length : -l.length;
+      o.setMetadata({
+        ...d,
+        [n]: Math.max(0, d[n] + r)
       });
     }
-    r.setItemAttrs(n, s);
+    o.setItemAttrs(i, s);
   }
-  async makeStatusUpdate(e, t, s) {
-    const a = Array.isArray(e) ? e : [e], r = a.map((n) => n.id), i = await this.knock.messages.batchUpdateStatuses(
-      r,
-      t,
+  async makeStatusUpdate(t, e, s) {
+    const n = Array.isArray(t) ? t : [t], o = n.map((i) => i.id), a = await this.knock.messages.batchUpdateStatuses(
+      o,
+      e,
       { metadata: s }
     );
-    return this.emitEvent(t, a), i;
+    return this.emitEvent(e, n), a;
   }
-  async makeBulkStatusUpdate(e) {
-    const t = {
+  async makeBulkStatusUpdate(t) {
+    const e = {
       user_ids: [this.knock.userId],
       engagement_status: this.defaultOptions.status !== "all" ? this.defaultOptions.status : void 0,
       archived: this.defaultOptions.archived,
@@ -342,13 +361,13 @@ class P {
     };
     return await this.knock.messages.bulkUpdateAllStatusesInChannel({
       channelId: this.feedId,
-      status: e,
-      options: t
+      status: t,
+      options: e
     });
   }
   setupBroadcastChannel() {
-    this.broadcastChannel = typeof self < "u" && "BroadcastChannel" in self ? new BroadcastChannel(`knock:feed:${this.userFeedId}`) : null, this.broadcastChannel && this.defaultOptions.__experimentalCrossBrowserUpdates === !0 && (this.broadcastChannel.onmessage = (e) => {
-      switch (e.data.type) {
+    this.broadcastChannel = typeof self < "u" && "BroadcastChannel" in self ? new BroadcastChannel(`knock:feed:${this.userFeedId}`) : null, this.broadcastChannel && this.defaultOptions.__experimentalCrossBrowserUpdates === !0 && (this.broadcastChannel.onmessage = (t) => {
+      switch (t.data.type) {
         case "items:archived":
         case "items:unarchived":
         case "items:seen":
@@ -364,29 +383,29 @@ class P {
       }
     });
   }
-  broadcastOverChannel(e, t) {
+  broadcastOverChannel(t, e) {
     if (this.broadcastChannel)
       try {
-        const s = JSON.parse(JSON.stringify(t));
+        const s = JSON.parse(JSON.stringify(e));
         this.broadcastChannel.postMessage({
-          type: e,
+          type: t,
           payload: s
         });
       } catch (s) {
-        console.warn(`Could not broadcast ${e}, got error: ${s}`);
+        console.warn(`Could not broadcast ${t}, got error: ${s}`);
       }
   }
   initializeRealtimeConnection() {
-    var e;
-    this.socketManager && (this.defaultOptions.auto_manage_socket_connection && this.setUpVisibilityListeners(), this.hasSubscribedToRealTimeUpdates && this.knock.isAuthenticated() && (this.unsubscribeFromSocketEvents = (e = this.socketManager) == null ? void 0 : e.join(this)));
+    var t;
+    this.socketManager && (this.defaultOptions.auto_manage_socket_connection && this.setUpVisibilityListeners(), this.hasSubscribedToRealTimeUpdates && this.knock.isAuthenticated() && (this.unsubscribeFromSocketEvents = (t = this.socketManager) == null ? void 0 : t.join(this)));
   }
-  async handleSocketEvent(e) {
-    switch (e.event) {
+  async handleSocketEvent(t) {
+    switch (t.event) {
       case y.NewMessage:
-        this.onNewMessageReceived(e);
+        this.onNewMessageReceived(t);
         return;
       default: {
-        e.event;
+        t.event;
         return;
       }
     }
@@ -404,16 +423,16 @@ class P {
       this.visibilityChangeHandler
     ), this.visibilityChangeListenerConnected = !1);
   }
-  emitEvent(e, t) {
-    this.broadcaster.emit(`items.${e}`, { items: t }), this.broadcaster.emit(`items:${e}`, { items: t }), this.broadcastOverChannel(`items:${e}`, { items: t });
+  emitEvent(t, e) {
+    this.broadcaster.emit(`items.${t}`, { items: e }), this.broadcaster.emit(`items:${t}`, { items: e }), this.broadcastOverChannel(`items:${t}`, { items: e });
   }
   handleVisibilityChange() {
-    var s, a;
-    const e = this.defaultOptions.auto_manage_socket_connection_delay ?? C, t = this.knock.client();
+    var s, n;
+    const t = this.defaultOptions.auto_manage_socket_connection_delay ?? U, e = this.knock.client();
     document.visibilityState === "hidden" ? this.disconnectTimer = setTimeout(() => {
-      var r;
-      (r = t.socket) == null || r.disconnect(), this.disconnectTimer = null;
-    }, e) : document.visibilityState === "visible" && (this.disconnectTimer && (clearTimeout(this.disconnectTimer), this.disconnectTimer = null), (s = t.socket) != null && s.isConnected() || (a = t.socket) == null || a.connect());
+      var o;
+      (o = e.socket) == null || o.disconnect(), this.disconnectTimer = null;
+    }, t) : document.visibilityState === "visible" && (this.disconnectTimer && (clearTimeout(this.disconnectTimer), this.disconnectTimer = null), (s = e.socket) != null && s.isConnected() || (n = e.socket) == null || n.connect());
   }
 }
 export {