@seamly/web-ui 20.7.0 → 20.8.0-beta.1

package/src/javascripts/ui/utils/seamly-utils.js

@@ -1,832 +0,0 @@
-import { randomId } from 'lib/id'
-import { getTimeFromSeconds } from './general-utils'
-
-export const eventTypes = {
-  info: 'info',
-  message: 'message',
-  participant: 'participant',
-  system: 'system',
-}
-
-export const payloadTypes = {
-  choicePrompt: 'choice_prompt',
-  text: 'text',
-  image: 'image',
-  video: 'video',
-  participant: 'participant',
-  divider: 'divider',
-  translation: 'translation',
-  message: 'message',
-  countdown: 'countdown',
-  upload: 'upload',
-  cta: 'cta',
-  splash: 'splash',
-}
-
-export const entryTypes = {
-  text: 'text',
-  upload: 'upload',
-}
-
-export const readStates = {
-  received: 'received',
-  read: 'read',
-}
-
-export const actionTypes = {
-  pickChoice: 'pick_choice',
-  navigate: 'navigate',
-  custom: 'custom',
-  typing: 'typing',
-  read: 'read',
-  detachService: 'detach_service',
-  interactivityUpdate: 'interactivity_update',
-  dismiss: 'dismiss',
-  sendTranscript: 'send_transcript',
-  setTopic: 'set_topic',
-  setTranslation: 'set_translation',
-  clickCta: 'click_cta',
-  clickCard: 'click_card',
-}
-
-export const dismissTypes = {
-  resumeConversationPrompt: 'resume_conversation_prompt',
-}
-
-export const ariaLiveLevels = {
-  assertive: 'assertive',
-  polite: 'polite',
-}
-
-export const dividerKeys = {
-  new_topic: 'newTopic',
-  new_translation: 'newTranslation',
-}
-
-export const featureKeys = {
-  sendTranscript: 'sendTranscript',
-  typingPeekahead: 'typingPeekahead',
-  uploads: 'uploads',
-}
-
-export const seamlyActions = {
-  ADD_EVENT: 'ADD_EVENT',
-  CLEAR_EVENTS: 'CLEAR_EVENTS',
-  SET_HISTORY: 'SET_HISTORY',
-  SET_EVENTS_READ: 'SET_EVENTS_READ',
-  SET_LOADED_IMAGE_EVENT_IDS: 'SET_LOADED_IMAGE_EVENT_IDS',
-  ACK_EVENT: 'ACK_EVENT',
-  SET_IS_LOADING: 'SET_IS_LOADING',
-  CLEAR_PARTICIPANTS: 'CLEAR_PARTICIPANTS',
-  SET_PARTICIPANT: 'SET_PARTICIPANT',
-  SET_HEADER_TITLE: 'SET_HEADER_TITLE',
-  SET_HEADER_SUB_TITLE: 'SET_HEADER_SUB_TITLE',
-  RESET_HISTORY_LOADED_FLAG: 'RESET_HISTORY_LOADED_FLAG',
-  SET_ACTIVE_SERVICE: 'SET_ACTIVE_SERVICE',
-  INIT_IDLE_DETACH_COUNTDOWN: 'INIT_IDLE_DETACH_COUNTDOWN',
-  DECREMENT_IDLE_DETACH_COUNTDOWN_COUNTER:
-    'DECREMENT_IDLE_DETACH_COUNTDOWN_COUNTER',
-  STOP_IDLE_DETACH_COUNTDOWN_COUNTER: 'STOP_IDLE_DETACH_COUNTDOWN_COUNTER',
-  CLEAR_IDLE_DETACH_COUNTDOWN: 'CLEAR_IDLE_DETACH_COUNTDOWN',
-  INIT_RESUME_CONVERSATION_PROMPT: 'INIT_RESUME_CONVERSATION_PROMPT',
-  CLEAR_RESUME_CONVERSATION_PROMPT: 'CLEAR_RESUME_CONVERSATION_PROMPT',
-  SET_SERVICE_DATA_ITEM: 'SET_SERVICE_DATA_ITEM',
-  SET_FEATURES: 'SET_FEATURES',
-  SET_FEATURE_ENABLED_STATE: 'SET_FEATURE_ENABLED_STATE',
-  CLEAR_FEATURES: 'CLEAR_FEATURES',
-  SET_INITIAL_STATE: 'SET_INITIAL_STATE',
-  SET_USER_SELECTED_OPTIONS: 'SET_USER_SELECTED_OPTIONS',
-  SET_USER_SELECTED_OPTION: 'SET_USER_SELECTED_OPTION',
-  SHOW_OPTION: 'SHOW_OPTION',
-  HIDE_OPTION: 'HIDE_OPTION',
-  SET_SERVICE_ENTRY_METADATA: 'SET_SERVICE_ENTRY_METADATA',
-  SET_BLOCK_AUTO_ENTRY_SWITCH: 'SET_BLOCK_AUTO_ENTRY_SWITCH',
-  SET_ACTIVE_ENTRY_TYPE: 'SET_ACTIVE_ENTRY_TYPE',
-  SET_USER_ENTRY_TYPE: 'SET_USER_ENTRY_TYPE',
-  REGISTER_UPLOAD: 'REGISTER_UPLOAD',
-  SET_UPLOAD_PROGRESS: 'SET_UPLOAD_PROGRESS',
-  SET_UPLOAD_COMPLETE: 'SET_UPLOAD_COMPLETE',
-  SET_UPLOAD_ERROR: 'SET_UPLOAD_ERROR',
-  CLEAR_UPLOAD: 'CLEAR_UPLOAD',
-  CLEAR_ALL_UPLOADS: 'CLEAR_ALL_UPLOADS',
-  SET_SEAMLY_CONTAINER_ELEMENT: 'SET_SEAMLY_CONTAINER_ELEMENT',
-}
-
-export const cardTypes = {
-  ask: 'ask',
-  navigate: 'navigate',
-  topic: 'topic',
-}
-
-const {
-  ADD_EVENT,
-  CLEAR_EVENTS,
-  SET_HISTORY,
-  SET_EVENTS_READ,
-  SET_LOADED_IMAGE_EVENT_IDS,
-  ACK_EVENT,
-  SET_IS_LOADING,
-  CLEAR_PARTICIPANTS,
-  SET_PARTICIPANT,
-  SET_HEADER_TITLE,
-  SET_HEADER_SUB_TITLE,
-  RESET_HISTORY_LOADED_FLAG,
-  SET_ACTIVE_SERVICE,
-  INIT_IDLE_DETACH_COUNTDOWN,
-  DECREMENT_IDLE_DETACH_COUNTDOWN_COUNTER,
-  STOP_IDLE_DETACH_COUNTDOWN_COUNTER,
-  CLEAR_IDLE_DETACH_COUNTDOWN,
-  INIT_RESUME_CONVERSATION_PROMPT,
-  CLEAR_RESUME_CONVERSATION_PROMPT,
-  SET_SERVICE_DATA_ITEM,
-  SET_FEATURES,
-  SET_FEATURE_ENABLED_STATE,
-  CLEAR_FEATURES,
-  SET_INITIAL_STATE,
-  SET_USER_SELECTED_OPTION,
-  SET_USER_SELECTED_OPTIONS,
-  SHOW_OPTION,
-  HIDE_OPTION,
-  SET_BLOCK_AUTO_ENTRY_SWITCH,
-  SET_USER_ENTRY_TYPE,
-  SET_ACTIVE_ENTRY_TYPE,
-  SET_SERVICE_ENTRY_METADATA,
-  REGISTER_UPLOAD,
-  SET_UPLOAD_PROGRESS,
-  SET_UPLOAD_COMPLETE,
-  SET_UPLOAD_ERROR,
-  CLEAR_UPLOAD,
-  CLEAR_ALL_UPLOADS,
-  SET_SEAMLY_CONTAINER_ELEMENT,
-} = seamlyActions
-
-export const isUnreadMessage = ({ type, payload }) =>
-  (type === eventTypes.message && !payload.fromClient) ||
-  (type === eventTypes.info && payload.type === payloadTypes.text)
-
-const orderHistory = (events) => {
-  return events.sort(
-    (
-      { payload: { occurredAt: occurredAtA } },
-      { payload: { occurredAt: occurredAtB } },
-    ) => occurredAtA - occurredAtB,
-  )
-}
-
-export const mergeHistory = (stateEvents, historyEvents) => {
-  const newStateEvents = stateEvents.filter(
-    (stateEvent) =>
-      // Deduplicate the event streams, giving events in historyEvents
-      // precedence so the server is able to push changes to events.
-      !historyEvents.some(
-        (historyEvent) => historyEvent.payload.id === stateEvent.payload.id,
-      ),
-  )
-
-  const newHistoryEvents = historyEvents
-    .filter(
-      (historyEvent) =>
-        // Remove all non displayable participant messages
-        !(
-          historyEvent.type === 'participant' &&
-          !historyEvent.payload.participant.introduction
-        ),
-    )
-    // Reverse is done here because the server sends the history in the order
-    // newest to oldest. In the case of exactly the same occurredAt timestamps
-    // these messages will be shown in the wrong order if not reversed. For
-    // the normal merging logic there is no added effect.
-    .reverse()
-
-  return orderHistory([...newHistoryEvents, ...newStateEvents])
-}
-
-const participantReducer = (state, action) => {
-  switch (action.type) {
-    case CLEAR_PARTICIPANTS:
-      return {
-        participants: {},
-        currentAgent: '',
-      }
-    case SET_PARTICIPANT:
-      // TODO: a) Styleguide only! b) Should be removed after styleguide overhaul.
-      if (!state) {
-        return {
-          participants: {},
-          currentAgent: '',
-        }
-      }
-
-      const { participants } = state || { participants: {} }
-      const { id, avatar, name, introduction } = action.participant
-      const oldParticipant = participants[id]
-
-      const newParticipants = {
-        ...participants,
-        [id]: oldParticipant
-          ? {
-              ...oldParticipant,
-              ...(avatar ? { avatar } : {}),
-              ...(name ? { name } : {}),
-              ...(introduction ? { introduction } : {}),
-            }
-          : action.participant,
-      }
-
-      return {
-        ...state,
-        participants: newParticipants,
-        currentAgent:
-          state.currentAgent !== id && !action.fromClient
-            ? id
-            : state.currentAgent,
-      }
-    default:
-      return state
-  }
-}
-
-const headerTitlesReducer = (state, action) => {
-  switch (action.type) {
-    case SET_HEADER_TITLE:
-      return {
-        ...state,
-        title: action.title,
-      }
-    case SET_HEADER_SUB_TITLE:
-      return {
-        ...state,
-        subTitle: action.title,
-      }
-    default:
-      return state
-  }
-}
-
-const calculateNewEntryMeta = (entryMeta, payload) => {
-  const { entry } = payload
-  const { blockAutoEntrySwitch } = entryMeta
-
-  if (!entry) {
-    return { ...entryMeta, optionsOverride: {} }
-  }
-
-  const { type, options } = entry
-
-  let newActive = entryMeta.active
-
-  if (!blockAutoEntrySwitch && type !== entryMeta.userSelected) {
-    newActive = type
-  }
-
-  return {
-    ...entryMeta,
-    active: newActive,
-    optionsOverride: {
-      ...entryMeta.optionsOverride,
-      [type]: options || {},
-    },
-  }
-}
-
-export const seamlyStateReducer = (state, action) => {
-  switch (action.type) {
-    case ADD_EVENT:
-      const { type: eventType, payload } = action.event
-
-      const accountHasUploads = state.options.features.hasOwnProperty(
-        featureKeys.uploads,
-      )
-
-      const newEntryMeta = calculateNewEntryMeta(state.entryMeta, payload)
-
-      let newOptions = { ...state.options }
-
-      // This enabled override of the service enabled value for uploads.
-      // If a message is sent with entry of type upload it will temporarily
-      // override service value and enable uploads.
-      if (
-        accountHasUploads &&
-        (eventType === eventTypes.message ||
-          eventType === eventTypes.participant) &&
-        !payload.fromClient
-      ) {
-        const entryType = payload?.entry?.type
-        newOptions = {
-          ...newOptions,
-          features: {
-            ...newOptions.features,
-            uploads: {
-              ...newOptions.features.uploads,
-              enabledFromEntry: entryType === entryTypes.upload,
-            },
-          },
-        }
-      }
-      const incrementUnread = isUnreadMessage(action.event)
-
-      // We check for duplicated and ignore them as in some error of the websocket
-      // a duplicate join can be active for a while until the server connection
-      // times out.
-      const eventExists = state.events.find((e) => e.payload.id === payload.id)
-      if (eventExists) {
-        return state
-      }
-
-      return {
-        ...state,
-        entryMeta:
-          !accountHasUploads && newEntryMeta.active === entryTypes.upload
-            ? { ...state.entryMeta }
-            : newEntryMeta,
-        options: newOptions,
-        unreadEvents: incrementUnread
-          ? state.unreadEvents + 1
-          : state.unreadEvents,
-        events: [
-          ...state.events,
-          {
-            ...action.event,
-            // The payload spread should be done after adding the message
-            // status to enable overriding the status when setting
-            // event optimistically.
-            payload: {
-              ...(incrementUnread && {
-                messageStatus: payload.fromClient
-                  ? readStates.read
-                  : readStates.received,
-              }),
-              // We add a randomid to use as key for mapping of Events to avoid rerendering
-              key: randomId(),
-              ...payload,
-            },
-          },
-        ],
-      }
-    case ACK_EVENT:
-      // If any ACKs are sent without transactionID the conversation crashes.
-      // Ensure that this edge case is handled gracefully.
-      if (!action.event.payload.transactionId) {
-        console.warn('ACK received without transaction ID.')
-        return state
-      }
-
-      const matchedEvent = state.events.find(
-        (m) => m.payload.transactionId === action.event.payload.transactionId,
-      )
-
-      const { id, occurredAt } = action.event.payload
-
-      return matchedEvent
-        ? {
-            ...state,
-            events: orderHistory(
-              state.events.map((m) =>
-                m.payload.id === matchedEvent.payload.id
-                  ? {
-                      ...m,
-                      payload: { ...m.payload, id, occurredAt },
-                    }
-                  : m,
-              ),
-            ),
-          }
-        : state
-
-    case CLEAR_EVENTS:
-      return { ...state, unreadEvents: 0, loadedImageEventIds: [], events: [] }
-    case SET_EVENTS_READ:
-      return {
-        ...state,
-        unreadEvents: 0,
-        events: state.events.map((event) => {
-          if (action.ids.indexOf(event.payload.id) !== -1) {
-            return {
-              ...event,
-              payload: {
-                ...event.payload,
-                ...(event.payload.messageStatus === readStates.received && {
-                  messageStatus: readStates.read,
-                }),
-              },
-            }
-          }
-          return event
-        }),
-      }
-    case SET_LOADED_IMAGE_EVENT_IDS:
-      return {
-        ...state,
-        loadedImageEventIds: [...state.loadedImageEventIds, action.eventId],
-      }
-    case SET_HISTORY:
-      const {
-        events: history,
-        participants,
-        activeServiceSessionId,
-        activeServiceSettings = {},
-        serviceData,
-        resumeConversationPrompt,
-      } = action.history
-
-      const events = mergeHistory(state.events, history)
-
-      const mergedParticipants = {
-        ...state.participantInfo.participants,
-        ...participants,
-      }
-
-      const lastParticipantEvent = events
-        .slice()
-        .reverse()
-        .find(
-          (m) =>
-            (m.type === 'message' || m.type === 'participant') &&
-            !m.payload.fromClient,
-        )
-
-      let lastParticipantId = null
-
-      if (lastParticipantEvent) {
-        if (lastParticipantEvent.type === 'message') {
-          lastParticipantId = lastParticipantEvent.payload.participant
-        }
-        if (lastParticipantEvent.type === 'participant') {
-          lastParticipantId = lastParticipantEvent.payload.participant.id
-        }
-      }
-
-      const { entry, uploads } = activeServiceSettings
-
-      const historyNewEntryMeta = calculateNewEntryMeta(
-        {
-          ...state.entryMeta,
-          ...entry,
-          active: entry.default || payloadTypes.text,
-          options: { ...(entry && entry.options ? entry.options : {}) },
-        },
-        events[events.length - 1].payload,
-      )
-
-      let newFeatures = { ...state.options.features }
-
-      const newFeaturesHasUpload = newFeatures.hasOwnProperty(
-        featureKeys.uploads,
-      )
-
-      // Only set uploads if it was initialised by the account config.
-      if (newFeaturesHasUpload) {
-        const entryType = lastParticipantEvent?.payload?.entry?.type
-        newFeatures = {
-          ...newFeatures,
-          uploads: {
-            enabled: !!(uploads && uploads.enabled),
-            enabledFromEntry: entryType === entryTypes.upload,
-          },
-        }
-      }
-
-      const returnState = {
-        ...state,
-        unreadEvents: events.filter(
-          (event) =>
-            event.type === 'message' &&
-            event.payload.messageStatus === readStates.received,
-        ).length,
-        events: events.filter(
-          (e) =>
-            e.type !== 'participant' || !!e.payload.participant.introduction,
-        ),
-        participantInfo: {
-          ...state.participantInfo,
-          ...(lastParticipantId
-            ? participantReducer(state.participantInfo, {
-                type: SET_PARTICIPANT,
-                participant: mergedParticipants[lastParticipantId],
-              })
-            : {}),
-          participants: mergedParticipants,
-        },
-        historyLoaded: true,
-        serviceInfo: {
-          ...state.serviceInfo,
-          activeServiceSessionId,
-        },
-        serviceData: serviceData || {},
-        options: {
-          ...state.options,
-          features: newFeatures,
-        },
-        entryMeta:
-          !newFeaturesHasUpload &&
-          historyNewEntryMeta.active === entryTypes.upload
-            ? { ...state.entryMeta }
-            : historyNewEntryMeta,
-        resumeConversationPrompt: resumeConversationPrompt || false,
-      }
-
-      if (lastParticipantId) {
-        returnState.headerTitles = headerTitlesReducer(state.headerTitles, {
-          type: SET_HEADER_SUB_TITLE,
-          title: mergedParticipants[lastParticipantId].name,
-        })
-      }
-
-      return returnState
-    case RESET_HISTORY_LOADED_FLAG:
-      return {
-        ...state,
-        historyLoaded: false,
-      }
-    case SET_IS_LOADING:
-      return { ...state, isLoading: action.isLoading }
-    case INIT_IDLE_DETACH_COUNTDOWN:
-      const { delaySeconds, delayTime } = action
-      return {
-        ...state,
-        idleDetachCountdown: {
-          hasCountdown: true,
-          isActive: true,
-          wasStopped: false,
-          count: delaySeconds,
-          remaining: delaySeconds,
-          timer: delayTime,
-        },
-      }
-    case DECREMENT_IDLE_DETACH_COUNTDOWN_COUNTER:
-      const { idleDetachCountdown } = state
-
-      const { remaining: prevRemaining } = idleDetachCountdown
-
-      const remaining = prevRemaining - 1
-
-      return {
-        ...state,
-        idleDetachCountdown: {
-          ...state.idleDetachCountdown,
-          remaining,
-          timer: getTimeFromSeconds(remaining),
-        },
-      }
-    case STOP_IDLE_DETACH_COUNTDOWN_COUNTER: {
-      return {
-        ...state,
-        idleDetachCountdown: {
-          ...state.idleDetachCountdown,
-          isActive: false,
-          wasStopped: true,
-        },
-      }
-    }
-    case CLEAR_IDLE_DETACH_COUNTDOWN:
-      return {
-        ...state,
-        idleDetachCountdown: { hasCountdown: false, isActive: false },
-      }
-    case INIT_RESUME_CONVERSATION_PROMPT:
-      return {
-        ...state,
-        resumeConversationPrompt: true,
-      }
-    case CLEAR_RESUME_CONVERSATION_PROMPT:
-      return {
-        ...state,
-        resumeConversationPrompt: false,
-      }
-    case SET_PARTICIPANT:
-    case CLEAR_PARTICIPANTS:
-      return {
-        ...state,
-        participantInfo: participantReducer(state.participantInfo, action),
-      }
-    case SET_ACTIVE_SERVICE:
-      if (
-        state.serviceInfo.activeServiceSessionId !==
-        action.activeServiceSessionId
-      ) {
-        return {
-          ...state,
-          serviceInfo: {
-            ...state.serviceInfo,
-            activeServiceSessionId: action.activeServiceSessionId,
-          },
-        }
-      }
-      return state
-    case SET_HEADER_TITLE:
-    case SET_HEADER_SUB_TITLE:
-      return {
-        ...state,
-        headerTitles: headerTitlesReducer(state.headerTitles, action),
-      }
-    case SET_INITIAL_STATE:
-      const { initialState } = action
-      return {
-        ...state,
-        initialState,
-        unreadEvents: initialState.unreadMessageCount,
-      }
-    case SET_SERVICE_DATA_ITEM:
-      return {
-        ...state,
-        serviceData: {
-          ...state.serviceData,
-          [action.payload.type]: action.payload,
-        },
-      }
-    case SET_FEATURES:
-      return {
-        ...state,
-        options: {
-          ...state.options,
-          features: action.features,
-        },
-      }
-    case SET_FEATURE_ENABLED_STATE:
-      return state.options.features.hasOwnProperty(action.key)
-        ? {
-            ...state,
-            options: {
-              ...state.options,
-              features: {
-                ...state.options.features,
-                [action.key]: {
-                  ...(state.options.features[action.key] || {}),
-                  enabled: action.enabled,
-                },
-              },
-            },
-          }
-        : state
-    case CLEAR_FEATURES:
-      return {
-        ...state,
-        options: {
-          ...state.options,
-          features: {},
-        },
-      }
-    case SHOW_OPTION:
-      return {
-        ...state,
-        options: {
-          ...state.options,
-          panelActive: true,
-          optionActive: action.optionName,
-        },
-      }
-    case HIDE_OPTION:
-      return {
-        ...state,
-        options: {
-          ...state.options,
-          panelActive: false,
-          optionActive: '',
-        },
-      }
-    case SET_USER_SELECTED_OPTIONS:
-      return {
-        ...state,
-        options: {
-          ...state.options,
-          userSelectedOptions: action.options,
-        },
-      }
-    case SET_USER_SELECTED_OPTION:
-      const { option, value } = action
-      return {
-        ...state,
-        options: {
-          ...state.options,
-          userSelectedOptions: {
-            ...state.options.userSelectedOptions,
-            [option]: value,
-          },
-        },
-      }
-    case SET_BLOCK_AUTO_ENTRY_SWITCH:
-      const { value: blockAutoEntrySwitch } = action
-
-      return {
-        ...state,
-        entryMeta: {
-          ...state.entryMeta,
-          blockAutoEntrySwitch,
-        },
-      }
-    case SET_SERVICE_ENTRY_METADATA:
-      const { entryMeta } = action
-
-      return {
-        ...state,
-        entryMeta: {
-          ...state.entryMeta,
-          ...entryMeta,
-          active: entryMeta.default,
-          options: { ...(entryMeta.options || {}) },
-          overrideOptions: {},
-        },
-      }
-    case SET_ACTIVE_ENTRY_TYPE:
-      const { entryType: active } = action
-
-      return {
-        ...state,
-        entryMeta: {
-          ...state.entryMeta,
-          active,
-        },
-      }
-    case SET_USER_ENTRY_TYPE:
-      const { entryType: userSelected } = action
-
-      return {
-        ...state,
-        entryMeta: {
-          ...state.entryMeta,
-          userSelected,
-        },
-      }
-    case REGISTER_UPLOAD:
-      return {
-        ...state,
-        currentUploads: [
-          ...state.currentUploads,
-          {
-            id: action.fileId,
-            name: action.fileName,
-            progress: 1,
-            uploading: true,
-            complete: false,
-            error: '',
-            uploadHandle: action.uploadHandle,
-          },
-        ],
-      }
-    case SET_UPLOAD_PROGRESS:
-      return {
-        ...state,
-        currentUploads: state.currentUploads.map((fileUpload) => {
-          if (fileUpload.id === action.fileId) {
-            return {
-              ...fileUpload,
-              progress: action.progress,
-              uploading: action.progress !== 100,
-              uploadHandle:
-                action.progress === 100 ? null : fileUpload.uploadHandle,
-            }
-          }
-          return fileUpload
-        }),
-      }
-    case SET_UPLOAD_ERROR:
-      return {
-        ...state,
-        currentUploads: state.currentUploads.map((fileUpload) => {
-          if (fileUpload.id === action.fileId) {
-            return {
-              ...fileUpload,
-              error: action.errorText,
-              progress: 0,
-              uploading: false,
-              uploadHandle: null,
-            }
-          }
-          return fileUpload
-        }),
-      }
-    case SET_UPLOAD_COMPLETE:
-      return {
-        ...state,
-        currentUploads: state.currentUploads.map((fileUpload) => {
-          if (fileUpload.id === action.fileId) {
-            return {
-              ...fileUpload,
-              complete: true,
-            }
-          }
-          return fileUpload
-        }),
-      }
-    case CLEAR_UPLOAD:
-      return {
-        ...state,
-        currentUploads: state.currentUploads.filter(
-          (fileUpload) => fileUpload.id !== action.fileId,
-        ),
-      }
-    case CLEAR_ALL_UPLOADS:
-      return {
-        ...state,
-        currentUploads: [],
-      }
-    case SET_SEAMLY_CONTAINER_ELEMENT: {
-      return {
-        ...state,
-        seamlyContainerElement: action.element,
-      }
-    }
-    default:
-      return state
-  }
-}