@seamly/web-ui 20.8.1 → 21.0.0

package/src/javascripts/ui/components/core/seamly-event-subscriber.js

@@ -1,279 +0,0 @@
-import SeamlyGeneralError from 'api/errors/seamly-general-error'
-import SeamlyOfflineError from 'api/errors/seamly-offline-error'
-import SeamlySessionExpiredError from 'api/errors/seamly-session-expired-error'
-import { setHasResponded } from 'domains/app/slice'
-import { clearInterrupt, setInterrupt } from 'domains/interrupt/slice'
-import {
-  ackEvent,
-  addEvent,
-  clearEvents,
-  initResumeConversationPrompt,
-  setActiveService,
-  setFeatureEnabledState,
-  setHeaderSubTitle,
-  setHistory,
-  setIsLoading,
-  setParticipant,
-  setServiceDataItem,
-  setServiceEntryMetadata,
-} from 'domains/store/slice'
-import { useEffect, useRef } from 'preact/hooks'
-import { useDispatch } from 'react-redux'
-import {
-  useEvents,
-  useSeamlyApiContext,
-  useSeamlyCommands,
-  useSeamlyIdleDetachCountdown,
-} from 'ui/hooks/seamly-hooks'
-import { featureKeys } from 'ui/utils/seamly-utils'
-
-const EMITTABLE_MESSAGE_TYPES = ['text', 'choice_prompt', 'image', 'video']
-
-const SeamlyEventSubscriber = ({ eventBus }) => {
-  const api = useSeamlyApiContext()
-  const dispatch = useDispatch()
-  const events = useEvents()
-  const prevEmittedEventId = useRef(null)
-  const { initCountdown, endCountdown } = useSeamlyIdleDetachCountdown()
-  const { emitEvent } = useSeamlyCommands()
-
-  useEffect(() => {
-    if (api.connectionInfo) {
-      const updateParticipant = (event) => {
-        const { payload } = event
-
-        if (!payload || !payload.participant) {
-          return
-        }
-
-        const { fromClient, participant } = payload
-
-        if (!fromClient && participant.name) {
-          dispatch(setHeaderSubTitle(participant.name))
-        }
-
-        dispatch(
-          setParticipant({
-            participant,
-            fromClient,
-          }),
-        )
-
-        if (participant.introduction) {
-          dispatch(addEvent(event))
-        }
-      }
-
-      const subscription = api.stream().subscribe({
-        next: (event) => {
-          const { type, payload } = event
-          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 'user_first_response':
-                  dispatch(setHasResponded(true))
-                  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.payload))
-              break
-            case 'system':
-              if (payload.type === 'service_changed') {
-                const { serviceSettings, ...eventPayload } = payload
-                const { entry } = serviceSettings
-                const { upload } = entry.options
-
-                dispatch(
-                  setFeatureEnabledState({
-                    key: featureKeys.uploads,
-                    enabled: !!(upload && upload.enabled),
-                  }),
-                )
-
-                dispatch(setServiceEntryMetadata(entry))
-                dispatch(setActiveService(payload.serviceSessionId))
-
-                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 'seamly_offline':
-                  const seamlyOfflineError = new SeamlyOfflineError(event)
-                  dispatch(
-                    setInterrupt({
-                      name: seamlyOfflineError.name,
-                      message: seamlyOfflineError.message,
-                      langKey: seamlyOfflineError.langKey,
-                      originalEvent: seamlyOfflineError.originalEvent,
-                      originalError: seamlyOfflineError.originalError,
-                    }),
-                  )
-                  dispatch(clearEvents())
-                  break
-                default:
-                  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
-              }
-              break
-            case 'socket_opened':
-              dispatch(clearInterrupt())
-              break
-          }
-        },
-      })
-
-      api
-        .stream()
-        .filter(
-          (e) =>
-            e.type === 'message' &&
-            EMITTABLE_MESSAGE_TYPES.includes(e.payload.type),
-        )
-        .subscribe({
-          next: ({ 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) {
-              eventBus.emit('message', payload)
-            }
-            prevEmittedEventId.current = payload.id
-          },
-        })
-      return () => {
-        subscription.unsubscribe()
-      }
-    }
-    return () => undefined
-  }, [dispatch, api, eventBus, initCountdown, endCountdown, emitEvent])
-
-  useEffect(() => {
-    const subscribe = () => {
-      return api
-        .stream()
-        .filter((e) => e.type === 'sync')
-        .subscribe({
-          next: (event) => {
-            const { payload } = event
-
-            const lastEvent = events[events.length - 1]
-            const { id: payloadLastEventId } = payload.lastEvent
-
-            if (lastEvent && payloadLastEventId === lastEvent.payload.id) {
-              return
-            }
-
-            api
-              .getConversation()
-              .then((history) => {
-                if (!history) {
-                  return
-                }
-
-                dispatch(setHistory(history))
-              })
-              .catch((error) => {
-                dispatch(
-                  setInterrupt({
-                    name: error.name,
-                    message: error.message,
-                    langKey: error.langKey,
-                    originalEvent: error.originalEvent,
-                    originalError: error.originalError,
-                  }),
-                )
-              })
-          },
-        })
-    }
-
-    if (api.stream) {
-      const subscription = subscribe()
-      return () => {
-        subscription.unsubscribe()
-      }
-    }
-
-    return () => undefined
-  }, [api, events, dispatch])
-
-  return null
-}
-
-export default SeamlyEventSubscriber