@seamly/web-ui 22.3.3 → 22.3.5-beta.1

package/build/dist/lib/standalone.js

@@ -659,6 +659,20 @@ var path = __webpack_require__(4058);
 module.exports = path.Promise;
 
 
+/***/ }),
+
+/***/ 6998:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+__webpack_require__(6274);
+__webpack_require__(5967);
+__webpack_require__(9008);
+__webpack_require__(7971);
+var path = __webpack_require__(4058);
+
+module.exports = path.Set;
+
+
 /***/ }),
 
 /***/ 1631:
@@ -1401,6 +1415,221 @@ module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
 };
 
 
+/***/ }),
+
+/***/ 5616:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var create = __webpack_require__(9290);
+var defineBuiltInAccessor = __webpack_require__(9202);
+var defineBuiltIns = __webpack_require__(4380);
+var bind = __webpack_require__(6843);
+var anInstance = __webpack_require__(5743);
+var isNullOrUndefined = __webpack_require__(2119);
+var iterate = __webpack_require__(3091);
+var defineIterator = __webpack_require__(5105);
+var createIterResultObject = __webpack_require__(3538);
+var setSpecies = __webpack_require__(4431);
+var DESCRIPTORS = __webpack_require__(5746);
+var fastKey = (__webpack_require__(1647).fastKey);
+var InternalStateModule = __webpack_require__(5402);
+
+var setInternalState = InternalStateModule.set;
+var internalStateGetterFor = InternalStateModule.getterFor;
+
+module.exports = {
+  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
+    var Constructor = wrapper(function (that, iterable) {
+      anInstance(that, Prototype);
+      setInternalState(that, {
+        type: CONSTRUCTOR_NAME,
+        index: create(null),
+        first: undefined,
+        last: undefined,
+        size: 0
+      });
+      if (!DESCRIPTORS) that.size = 0;
+      if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });
+    });
+
+    var Prototype = Constructor.prototype;
+
+    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
+
+    var define = function (that, key, value) {
+      var state = getInternalState(that);
+      var entry = getEntry(that, key);
+      var previous, index;
+      // change existing entry
+      if (entry) {
+        entry.value = value;
+      // create new entry
+      } else {
+        state.last = entry = {
+          index: index = fastKey(key, true),
+          key: key,
+          value: value,
+          previous: previous = state.last,
+          next: undefined,
+          removed: false
+        };
+        if (!state.first) state.first = entry;
+        if (previous) previous.next = entry;
+        if (DESCRIPTORS) state.size++;
+        else that.size++;
+        // add to index
+        if (index !== 'F') state.index[index] = entry;
+      } return that;
+    };
+
+    var getEntry = function (that, key) {
+      var state = getInternalState(that);
+      // fast case
+      var index = fastKey(key);
+      var entry;
+      if (index !== 'F') return state.index[index];
+      // frozen object case
+      for (entry = state.first; entry; entry = entry.next) {
+        if (entry.key == key) return entry;
+      }
+    };
+
+    defineBuiltIns(Prototype, {
+      // `{ Map, Set }.prototype.clear()` methods
+      // https://tc39.es/ecma262/#sec-map.prototype.clear
+      // https://tc39.es/ecma262/#sec-set.prototype.clear
+      clear: function clear() {
+        var that = this;
+        var state = getInternalState(that);
+        var data = state.index;
+        var entry = state.first;
+        while (entry) {
+          entry.removed = true;
+          if (entry.previous) entry.previous = entry.previous.next = undefined;
+          delete data[entry.index];
+          entry = entry.next;
+        }
+        state.first = state.last = undefined;
+        if (DESCRIPTORS) state.size = 0;
+        else that.size = 0;
+      },
+      // `{ Map, Set }.prototype.delete(key)` methods
+      // https://tc39.es/ecma262/#sec-map.prototype.delete
+      // https://tc39.es/ecma262/#sec-set.prototype.delete
+      'delete': function (key) {
+        var that = this;
+        var state = getInternalState(that);
+        var entry = getEntry(that, key);
+        if (entry) {
+          var next = entry.next;
+          var prev = entry.previous;
+          delete state.index[entry.index];
+          entry.removed = true;
+          if (prev) prev.next = next;
+          if (next) next.previous = prev;
+          if (state.first == entry) state.first = next;
+          if (state.last == entry) state.last = prev;
+          if (DESCRIPTORS) state.size--;
+          else that.size--;
+        } return !!entry;
+      },
+      // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods
+      // https://tc39.es/ecma262/#sec-map.prototype.foreach
+      // https://tc39.es/ecma262/#sec-set.prototype.foreach
+      forEach: function forEach(callbackfn /* , that = undefined */) {
+        var state = getInternalState(this);
+        var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+        var entry;
+        while (entry = entry ? entry.next : state.first) {
+          boundFunction(entry.value, entry.key, this);
+          // revert to the last existing entry
+          while (entry && entry.removed) entry = entry.previous;
+        }
+      },
+      // `{ Map, Set}.prototype.has(key)` methods
+      // https://tc39.es/ecma262/#sec-map.prototype.has
+      // https://tc39.es/ecma262/#sec-set.prototype.has
+      has: function has(key) {
+        return !!getEntry(this, key);
+      }
+    });
+
+    defineBuiltIns(Prototype, IS_MAP ? {
+      // `Map.prototype.get(key)` method
+      // https://tc39.es/ecma262/#sec-map.prototype.get
+      get: function get(key) {
+        var entry = getEntry(this, key);
+        return entry && entry.value;
+      },
+      // `Map.prototype.set(key, value)` method
+      // https://tc39.es/ecma262/#sec-map.prototype.set
+      set: function set(key, value) {
+        return define(this, key === 0 ? 0 : key, value);
+      }
+    } : {
+      // `Set.prototype.add(value)` method
+      // https://tc39.es/ecma262/#sec-set.prototype.add
+      add: function add(value) {
+        return define(this, value = value === 0 ? 0 : value, value);
+      }
+    });
+    if (DESCRIPTORS) defineBuiltInAccessor(Prototype, 'size', {
+      configurable: true,
+      get: function () {
+        return getInternalState(this).size;
+      }
+    });
+    return Constructor;
+  },
+  setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {
+    var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';
+    var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);
+    var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);
+    // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods
+    // https://tc39.es/ecma262/#sec-map.prototype.entries
+    // https://tc39.es/ecma262/#sec-map.prototype.keys
+    // https://tc39.es/ecma262/#sec-map.prototype.values
+    // https://tc39.es/ecma262/#sec-map.prototype-@@iterator
+    // https://tc39.es/ecma262/#sec-set.prototype.entries
+    // https://tc39.es/ecma262/#sec-set.prototype.keys
+    // https://tc39.es/ecma262/#sec-set.prototype.values
+    // https://tc39.es/ecma262/#sec-set.prototype-@@iterator
+    defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {
+      setInternalState(this, {
+        type: ITERATOR_NAME,
+        target: iterated,
+        state: getInternalCollectionState(iterated),
+        kind: kind,
+        last: undefined
+      });
+    }, function () {
+      var state = getInternalIteratorState(this);
+      var kind = state.kind;
+      var entry = state.last;
+      // revert to the last existing entry
+      while (entry && entry.removed) entry = entry.previous;
+      // get next entry
+      if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {
+        // or finish the iteration
+        state.target = undefined;
+        return createIterResultObject(undefined, true);
+      }
+      // return step by kind
+      if (kind == 'keys') return createIterResultObject(entry.key, false);
+      if (kind == 'values') return createIterResultObject(entry.value, false);
+      return createIterResultObject([entry.key, entry.value], false);
+    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
+
+    // `{ Map, Set }.prototype[@@species]` accessors
+    // https://tc39.es/ecma262/#sec-get-map-@@species
+    // https://tc39.es/ecma262/#sec-get-set-@@species
+    setSpecies(CONSTRUCTOR_NAME);
+  }
+};
+
+
 /***/ }),
 
 /***/ 8850:
@@ -7148,6 +7377,32 @@ $({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR
 });
 
 
+/***/ }),
+
+/***/ 2266:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var collection = __webpack_require__(4683);
+var collectionStrong = __webpack_require__(5616);
+
+// `Set` constructor
+// https://tc39.es/ecma262/#sec-set-objects
+collection('Set', function (init) {
+  return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };
+}, collectionStrong);
+
+
+/***/ }),
+
+/***/ 9008:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+// TODO: Remove this module from `core-js@4` since it's replaced to module below
+__webpack_require__(2266);
+
+
 /***/ }),
 
 /***/ 1035:
@@ -9705,6 +9960,17 @@ var path = __webpack_require__(4058);
 module.exports = path.setTimeout;
 
 
+/***/ }),
+
+/***/ 5519:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var parent = __webpack_require__(6998);
+__webpack_require__(7634);
+
+module.exports = parent;
+
+
 /***/ }),
 
 /***/ 7641:
@@ -10359,6 +10625,13 @@ module.exports = __webpack_require__(7989);
 
 /***/ }),
 
+/***/ 7487:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+module.exports = __webpack_require__(5519);
+
+/***/ }),
+
 /***/ 3460:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
@@ -10966,6 +11239,9 @@ function store(key) {
     }
   };
 }
+// EXTERNAL MODULE: ./node_modules/@babel/runtime-corejs3/core-js-stable/set.js
+var set = __webpack_require__(7487);
+var set_default = /*#__PURE__*/__webpack_require__.n(set);
 ;// CONCATENATED MODULE: ./node_modules/phoenix/priv/static/phoenix.mjs
 // js/phoenix/utils.js
 var closure = (value) => {
@@ -12150,6 +12426,7 @@ const splitUrlParams = url => {
 
 
 
+
 var __awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function (resolve) {
@@ -12194,6 +12471,14 @@ var _ConversationConnector_instances, _ConversationConnector_connectionListeners
 
 
 const log = debug_default()('seamly');
+// Subscribers set which are used to subscribe to changes in the conversation.
+// Needs to be outside of the ConversationConnector class so its not recreated for each instance.
+const subscribers = new (set_default())();
+// Syncs the lifecycle of the conversation with Preact. Each subscriber will fetch the latest value from the conversation if needed.
+const emitChange = () => {
+  // Call the callback function for each subscriber
+  for_each_default()(subscribers).call(subscribers, callback => callback());
+};
 class ConversationConnector {
   constructor() {
     _ConversationConnector_instances.add(this);
@@ -12209,35 +12494,37 @@ class ConversationConnector {
         url: splittedUrl,
         params
       } = split_url_params(this.url);
-      if (!this.socket) {
-        this.socket = new Socket(splittedUrl, {
-          params: assign_default()(assign_default()({}, params), {
-            v: apiVersion
-          }),
-          reconnectAfterMs: tries => {
-            // Calculate the backoff time based on the number of tries.
-            const backoff = Math.pow(2, tries) * 250;
-            // Limit the backoff time to 10 seconds.
-            return Math.min(backoff, 10000);
-          }
-        });
-      }
-      // Checks if the socket is not already connected before attempting a connection.
-      // This prevents multiple connection attempts during server reconnects, network switches or SPA route changes.
-      if (!this.socket.isConnected()) {
-        this.socket.connect();
-      }
-      this.channel = this.socket.channel(this.channelTopic, {
-        authorization: `Bearer ${this.accessToken}`,
-        channelName: this.channelName
+      this.socket = new Socket(splittedUrl, {
+        params: assign_default()(assign_default()({}, params), {
+          v: apiVersion
+        }),
+        reconnectAfterMs: tries => {
+          // Calculate the backoff time based on the number of tries.
+          const backoff = Math.pow(2, tries) * 250;
+          // Limit the backoff time to 10 seconds.
+          return Math.min(backoff, 10000);
+        }
       });
-      this.start();
       this.socket.onError(err => {
         log('[SOCKET][ERROR]', err);
       });
       this.socket.onOpen(() => {
         log('[SOCKET]OPEN');
       });
+      this.socket.onClose(() => {
+        log('[SOCKET]CLOSE');
+        __classPrivateFieldGet(this, _ConversationConnector_instances, "m", _ConversationConnector_emitConnectionState).call(this, {
+          connected: false,
+          ready: false,
+          currentState: 'socket_closed'
+        });
+      });
+      this.socket.connect();
+      this.channel = this.socket.channel(this.channelTopic, {
+        authorization: `Bearer ${this.accessToken}`,
+        channelName: this.channelName
+      });
+      this.start();
       this.channel.on('system', msg => {
         switch (msg.type) {
           case 'attach_channel_succeeded':
@@ -12249,14 +12536,6 @@ class ConversationConnector {
             break;
         }
       });
-      this.socket.onClose(() => {
-        log('[SOCKET]CLOSE');
-        __classPrivateFieldGet(this, _ConversationConnector_instances, "m", _ConversationConnector_emitConnectionState).call(this, {
-          connected: false,
-          ready: false,
-          currentState: 'socket_closed'
-        });
-      });
       this.channel.onClose(() => {
         log('[CHANNEL]CLOSE');
         __classPrivateFieldGet(this, _ConversationConnector_instances, "m", _ConversationConnector_emitConnectionState).call(this, {
@@ -12311,6 +12590,13 @@ class ConversationConnector {
     let timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10000;
     this.channel.push(command, payload, timeout);
   }
+  // Adds a callback function to the subscribers set and returns a method to unsubscribe from the store.
+  // This method is used to sync the state with the lifecycle of Preact.
+  static subscribe(callback) {
+    subscribers.add(callback);
+    // Returns a function that removes the callback from the subscribers set.
+    return () => subscribers.delete(callback);
+  }
 }
 _ConversationConnector_connectionListeners = new (weak_map_default())(), _ConversationConnector_instances = new (weak_set_default())(), _ConversationConnector_listenTo = function _ConversationConnector_listenTo() {
   for (var _len = arguments.length, types = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -12328,6 +12614,7 @@ _ConversationConnector_connectionListeners = new (weak_map_default())(), _Conver
     // If we only want to execute the callback once, remove it from the listener
     return !complete;
   }), "f");
+  emitChange();
 };
 /* harmony default export */ var conversation_connector = (ConversationConnector);
 ;// CONCATENATED MODULE: ./src/javascripts/api/index.ts
@@ -12871,7 +13158,7 @@ _API_ready = new (weak_map_default())(), _API_externalId = new (weak_map_default
   return {
     clientName: "@seamly/web-ui",
     clientVariant: api_classPrivateFieldGet(this, _API_layoutMode, "f"),
-    clientVersion: "22.3.3",
+    clientVersion: "22.3.5-beta.1",
     currentUrl: window.location.toString(),
     screenResolution: `${window.screen.width}x${window.screen.height}`,
     timezone: getTimeZone(),
@@ -20423,6 +20710,16 @@ const useSeamlyMessageContainerClassNames = event => {
   }
   return classNames;
 };
+;// CONCATENATED MODULE: ./src/javascripts/ui/hooks/use-seamly-conversation.ts
+
+
+
+const useSeamlyConversation = () => {
+  const api = useSeamlyApiContext();
+  const getSnapshot = () => api.conversation;
+  return (0,compat_module.useSyncExternalStore)(conversation_connector.subscribe, getSnapshot);
+};
+/* harmony default export */ var use_seamly_conversation = (useSeamlyConversation);
 ;// CONCATENATED MODULE: ./src/javascripts/ui/hooks/focus-helper-hooks.js
 
 
@@ -20880,12 +21177,12 @@ const useStableCallback = callback => {
 // and imported directly from this file
 // Please do not remove
 const useSeamlyEventStream = (nextFn, filterFn) => {
-  const api = useSeamlyApiContext();
+  const conversation = use_seamly_conversation();
   (0,hooks_module/* useEffect */.d4)(() => {
-    if (api.connectionInfo && api.conversation?.channel) {
+    if (conversation.channel) {
       const {
         channel
-      } = api.conversation;
+      } = conversation;
       channel.onMessage = (type, payload) => {
         if (!filterFn || filterFn({
           type,
@@ -20899,7 +21196,7 @@ const useSeamlyEventStream = (nextFn, filterFn) => {
         return payload;
       };
     }
-  }, [nextFn, filterFn, api.connectionInfo, api.conversation]);
+  }, [nextFn, filterFn, conversation]);
 };
 ;// CONCATENATED MODULE: ./src/javascripts/domains/translations/selectors.ts
 
@@ -24587,9 +24884,10 @@ var seamly_event_subscriber_rest = undefined && undefined.__rest || function (s,
 
 
 
+
 const EMITTABLE_MESSAGE_TYPES = ['text', 'choice_prompt', 'image', 'video'];
 const SeamlyEventSubscriber = () => {
-  const api = useSeamlyApiContext();
+  const conversation = use_seamly_conversation();
   const syncChannelRef = (0,hooks_module/* useRef */.sO)();
   const messageChannelRef = (0,hooks_module/* useRef */.sO)();
   const dispatch = useAppDispatch();
@@ -24603,10 +24901,10 @@ const SeamlyEventSubscriber = () => {
     emitEvent
   } = use_seamly_commands();
   (0,hooks_module/* useEffect */.d4)(() => {
-    if (api.connectionInfo && api.conversation.socket) {
+    if (conversation.socket) {
       const {
         socket
-      } = api.conversation;
+      } = conversation;
       socket.onError(err => {
         const seamlyOfflineError = new SeamlyOfflineError(err);
         dispatch(setInterrupt({
@@ -24622,10 +24920,10 @@ const SeamlyEventSubscriber = () => {
         dispatch(clearInterrupt());
       });
     }
-  }, [api, api.connectionInfo, api.conversation.socket, dispatch]);
+  }, [conversation, dispatch]);
   (0,hooks_module/* useEffect */.d4)(() => {
-    if (api.connectionInfo && api.conversation.socket) {
-      api.conversation.onConnection(_ref => {
+    if (conversation.socket) {
+      conversation.onConnection(_ref => {
         let {
           currentState
         } = _ref;
@@ -24644,220 +24942,213 @@ const SeamlyEventSubscriber = () => {
         return false;
       });
     }
-  }, [api, api.connectionInfo, api.conversation.channel, dispatch]);
+  }, [conversation, dispatch]);
   (0,hooks_module/* useEffect */.d4)(() => {
-    if (api.connectionInfo) {
-      const updateParticipant = event => {
-        if (event.type !== 'participant') {
-          return;
-        }
-        const {
+    const updateParticipant = event => {
+      if (event.type !== 'participant') {
+        return;
+      }
+      const {
+        payload
+      } = event;
+      if (!payload || !payload.participant) {
+        return;
+      }
+      const {
+        fromClient,
+        participant
+      } = payload;
+      if (!fromClient && typeof participant !== 'string' && (participant === null || participant === void 0 ? void 0 : participant.name)) {
+        dispatch(setHeaderSubTitle(participant.name));
+      }
+      dispatch(setParticipant({
+        participant,
+        fromClient
+      }));
+      if (typeof participant !== 'string' && participant.introduction) {
+        dispatch(addEvent(event));
+      }
+    };
+    conversation.onConnection(_ref2 => {
+      let {
+        connected
+      } = _ref2;
+      if (!connected) return false;
+      const {
+        channel
+      } = conversation;
+      channel.onMessage = (type, payload) => {
+        const event = {
+          type,
           payload
-        } = event;
-        if (!payload || !payload.participant) {
-          return;
-        }
-        const {
-          fromClient,
-          participant
-        } = payload;
-        if (!fromClient && typeof participant !== 'string' && (participant === null || participant === void 0 ? void 0 : participant.name)) {
-          dispatch(setHeaderSubTitle(participant.name));
-        }
-        dispatch(setParticipant({
-          participant,
-          fromClient
-        }));
-        if (typeof participant !== 'string' && participant.introduction) {
-          dispatch(addEvent(event));
-        }
-      };
-      api.conversation.onConnection(_ref2 => {
-        let {
-          connected
-        } = _ref2;
-        if (!connected) return false;
-        const {
-          channel
-        } = api.conversation;
-        channel.onMessage = (type, payload) => {
-          const event = {
-            type,
-            payload
-          };
-          switch (type) {
-            case 'ui':
-              if (payload.state && payload.state.hasOwnProperty('loading')) {
-                dispatch(setIsLoading(payload.state.loading));
-              }
-              switch (payload.type) {
-                case 'idle_detach_countdown':
-                  initCountdown(payload.body.duration);
-                  break;
-                case 'idle_detach_countdown_elapsed':
-                  endCountdown(undefined, true);
-                  break;
-                case 'resume_conversation_prompt':
-                  dispatch(initResumeConversationPrompt());
-                  break;
-                case 'translation_proposal':
-                  dispatch(setTranslationProposalPrompt(payload.body));
-                  break;
-                case 'user_first_response':
-                  dispatch(setHasResponded(true));
-                  // @ts-ignore
-                  eventBus.emit('system.userFirstResponse', payload.body);
-                  break;
-              }
-              break;
-            case 'message':
-              updateParticipant(payload);
-              switch (payload.type) {
-                case 'text':
-                case 'choice_prompt':
-                case 'splash':
-                case 'image':
-                case 'upload':
-                case 'video':
-                case 'cta':
-                case 'custom':
-                case 'carousel':
-                case 'card':
-                  if (payload.service && payload.service.serviceSessionId) {
-                    dispatch(setActiveService(payload.service.serviceSessionId));
-                  }
-                  dispatch(addEvent(event));
-                  break;
-              }
-              break;
-            case 'participant':
-              updateParticipant(event);
-              break;
-            case 'service_data':
-              if (payload.persist) {
-                dispatch(setServiceDataItem(payload));
-              }
-              break;
-            case 'ack':
-              dispatch(ackEvent(event));
-              break;
-            case 'system':
-              if (payload.type === 'service_changed') {
-                const {
-                    serviceSettings
-                  } = payload,
-                  eventPayload = seamly_event_subscriber_rest(payload, ["serviceSettings"]);
-                const {
-                  entry,
-                  proactiveMessages
-                } = serviceSettings;
-                const {
-                  upload
-                } = entry.options;
-                dispatch(setFeatureEnabledState({
-                  key: featureKeys.uploads,
-                  enabled: !!(upload && upload.enabled)
-                }));
-                dispatch(setProactiveMessages(proactiveMessages.enabled || false));
-                dispatch(setServiceEntryMetadata(entry));
-                if (payload.serviceSessionId) {
-                  dispatch(setActiveService(payload.serviceSessionId));
+        };
+        switch (type) {
+          case 'ui':
+            if (payload.state && payload.state.hasOwnProperty('loading')) {
+              dispatch(setIsLoading(payload.state.loading));
+            }
+            switch (payload.type) {
+              case 'idle_detach_countdown':
+                initCountdown(payload.body.duration);
+                break;
+              case 'idle_detach_countdown_elapsed':
+                endCountdown(undefined, true);
+                break;
+              case 'resume_conversation_prompt':
+                dispatch(initResumeConversationPrompt());
+                break;
+              case 'translation_proposal':
+                dispatch(setTranslationProposalPrompt(payload.body));
+                break;
+              case 'user_first_response':
+                dispatch(setHasResponded(true));
+                // @ts-ignore
+                eventBus.emit('system.userFirstResponse', payload.body);
+                break;
+            }
+            break;
+          case 'message':
+            updateParticipant(payload);
+            switch (payload.type) {
+              case 'text':
+              case 'choice_prompt':
+              case 'splash':
+              case 'image':
+              case 'upload':
+              case 'video':
+              case 'cta':
+              case 'custom':
+              case 'carousel':
+              case 'card':
+                if (payload.service && payload.service.serviceSessionId) {
+                  dispatch(setActiveService(payload.service.serviceSessionId));
                 }
-                emitEvent('system.serviceChanged', eventPayload);
-              }
-              break;
-            case 'info':
-              if (payload.type === 'divider' || payload.type === 'text' || payload.type === 'translation') {
                 dispatch(addEvent(event));
+                break;
+            }
+            break;
+          case 'participant':
+            updateParticipant(event);
+            break;
+          case 'service_data':
+            if (payload.persist) {
+              dispatch(setServiceDataItem(payload));
+            }
+            break;
+          case 'ack':
+            dispatch(ackEvent(event));
+            break;
+          case 'system':
+            if (payload.type === 'service_changed') {
+              const {
+                  serviceSettings
+                } = payload,
+                eventPayload = seamly_event_subscriber_rest(payload, ["serviceSettings"]);
+              const {
+                entry,
+                proactiveMessages
+              } = serviceSettings;
+              const {
+                upload
+              } = entry.options;
+              dispatch(setFeatureEnabledState({
+                key: featureKeys.uploads,
+                enabled: !!(upload && upload.enabled)
+              }));
+              dispatch(setProactiveMessages(proactiveMessages.enabled || false));
+              dispatch(setServiceEntryMetadata(entry));
+              if (payload.serviceSessionId) {
+                dispatch(setActiveService(payload.serviceSessionId));
               }
-              break;
-            case 'error':
-              switch (payload.type) {
-                case 'find_conversation_erred':
-                  const seamlySessionExpiredError = new SeamlySessionExpiredError(event);
-                  dispatch(setInterrupt({
-                    name: seamlySessionExpiredError.name,
-                    action: seamlySessionExpiredError.action,
-                    message: seamlySessionExpiredError.message,
-                    originalEvent: seamlySessionExpiredError.originalEvent,
-                    originalError: seamlySessionExpiredError.originalError
-                  }));
-                  break;
-                case 'conversation_erred':
-                case 'attach_channel_erred':
-                  const seamlyGeneralError = new SeamlyGeneralError(event);
-                  dispatch(setInterrupt({
-                    name: seamlyGeneralError.name,
-                    message: seamlyGeneralError.message,
-                    langKey: seamlyGeneralError.langKey,
-                    originalEvent: seamlyGeneralError.originalEvent,
-                    originalError: seamlyGeneralError.originalError,
-                    action: seamlyGeneralError.action
-                  }));
-                  break;
-              }
-          }
-          return payload;
-        };
-        return false;
-      });
-    }
-  }, [api, api.connectionInfo, api.conversation.channel, dispatch, emitEvent, endCountdown, eventBus, initCountdown]);
-  (0,hooks_module/* useEffect */.d4)(() => {
-    if (api.connectionInfo) {
-      api.conversation.onConnection(_ref3 => {
-        let {
-          connected
-        } = _ref3;
-        if (!connected) return false;
-        const {
-          channel
-        } = api.conversation;
-        if (messageChannelRef.current) {
-          channel === null || channel === void 0 ? void 0 : channel.off('message', messageChannelRef.current);
+              emitEvent('system.serviceChanged', eventPayload);
+            }
+            break;
+          case 'info':
+            if (payload.type === 'divider' || payload.type === 'text' || payload.type === 'translation') {
+              dispatch(addEvent(event));
+            }
+            break;
+          case 'error':
+            switch (payload.type) {
+              case 'find_conversation_erred':
+                const seamlySessionExpiredError = new SeamlySessionExpiredError(event);
+                dispatch(setInterrupt({
+                  name: seamlySessionExpiredError.name,
+                  action: seamlySessionExpiredError.action,
+                  message: seamlySessionExpiredError.message,
+                  originalEvent: seamlySessionExpiredError.originalEvent,
+                  originalError: seamlySessionExpiredError.originalError
+                }));
+                break;
+              case 'conversation_erred':
+              case 'attach_channel_erred':
+                const seamlyGeneralError = new SeamlyGeneralError(event);
+                dispatch(setInterrupt({
+                  name: seamlyGeneralError.name,
+                  message: seamlyGeneralError.message,
+                  langKey: seamlyGeneralError.langKey,
+                  originalEvent: seamlyGeneralError.originalEvent,
+                  originalError: seamlyGeneralError.originalError,
+                  action: seamlyGeneralError.action
+                }));
+                break;
+            }
         }
-        messageChannelRef.current = channel.on('message', payload => {
-          if (!includes_default()(EMITTABLE_MESSAGE_TYPES).call(EMITTABLE_MESSAGE_TYPES, payload.type)) {
-            return payload;
-          }
-          // This check dedupes the sending of messages via
-          // the bus if a duplicate connection exists in an
-          // error situation.
-          if (payload.id !== prevEmittedEventId.current) {
-            // @ts-ignore
-            eventBus.emit('message', payload);
-          }
-          prevEmittedEventId.current = payload.id;
+        return payload;
+      };
+      return false;
+    });
+  }, [conversation, dispatch, emitEvent, endCountdown, eventBus, initCountdown]);
+  (0,hooks_module/* useEffect */.d4)(() => {
+    conversation.onConnection(_ref3 => {
+      let {
+        connected
+      } = _ref3;
+      if (!connected) return false;
+      const {
+        channel
+      } = conversation;
+      if (messageChannelRef.current) {
+        channel.off('message', messageChannelRef.current);
+      }
+      messageChannelRef.current = channel.on('message', payload => {
+        if (!includes_default()(EMITTABLE_MESSAGE_TYPES).call(EMITTABLE_MESSAGE_TYPES, payload.type)) {
           return payload;
-        });
-        return true;
+        }
+        // This check dedupes the sending of messages via
+        // the bus if a duplicate connection exists in an
+        // error situation.
+        if (payload.id !== prevEmittedEventId.current) {
+          // @ts-ignore
+          eventBus.emit('message', payload);
+        }
+        prevEmittedEventId.current = payload.id;
+        return payload;
       });
-    }
-  }, [api, api.connectionInfo, api.conversation.channel, eventBus]);
+      return true;
+    });
+  }, [conversation, eventBus]);
   (0,hooks_module/* useEffect */.d4)(() => {
-    if (api.connectionInfo) {
-      api.conversation.onConnection(_ref4 => {
-        let {
-          connected
-        } = _ref4;
-        var _a;
-        if (!connected) return false;
-        if (syncChannelRef.current) {
-          (_a = api.conversation.channel) === null || _a === void 0 ? void 0 : _a.off('sync', syncChannelRef.current);
+    conversation.onConnection(_ref4 => {
+      let {
+        connected
+      } = _ref4;
+      if (!connected) return false;
+      if (syncChannelRef.current) {
+        conversation.channel.off('sync', syncChannelRef.current);
+      }
+      syncChannelRef.current = conversation.channel.on('sync', payload => seamly_event_subscriber_awaiter(void 0, void 0, void 0, function* () {
+        try {
+          const history = yield dispatch(getConversation(payload)).unwrap();
+          if (!history) return;
+          dispatch(setHistory(history));
+        } catch (_e) {
+          // nothing to do, the error is handled in the thunk
         }
-        syncChannelRef.current = api.conversation.channel.on('sync', payload => seamly_event_subscriber_awaiter(void 0, void 0, void 0, function* () {
-          try {
-            const history = yield dispatch(getConversation(payload)).unwrap();
-            if (!history) return;
-            dispatch(setHistory(history));
-          } catch (_e) {
-            // nothing to do, the error is handled in the thunk
-          }
-        }));
-        return true;
-      });
-    }
-  }, [api, api.connectionInfo, api.conversation.channel, dispatch]);
+      }));
+      return true;
+    });
+  }, [conversation, dispatch]);
   return null;
 };
 /* harmony default export */ var seamly_event_subscriber = (SeamlyEventSubscriber);
@@ -28640,7 +28931,7 @@ const useNotification = () => {
   const [visibilityState, setVisibilityState] = (0,hooks_module/* useState */.eJ)(document.visibilityState);
   const showNotifications = useSelector_useSelector(selectShowNotifications);
   const requestPermission = (0,hooks_module/* useCallback */.I4)(() => use_notifications_awaiter(void 0, void 0, void 0, function* () {
-    if (Notification && permission !== 'granted') {
+    if (hasNotificationSupport && permission !== 'granted') {
       const notificationPermission = yield Notification.requestPermission();
       setPermission(notificationPermission);
     }