keet-deobfuscated / @holepunchto / keet-store / store / call / call-presence.reducer.js

import { STREAM_TYPE as e, PRESENCE_EVT as r } from "./call.constants"
import {
  getEmptyMemberMedia as m,
  getEmptyMemberPresence as d,
  hasStreamEverAdded as a,
  removeFromPresencesSortedByActivity as s,
  updatePresencesSortedByActivity as t,
} from "./utils"
export const addCallUnknownPresenceEvtReducer = (e, { payload: m }) => {
  if (!m || !m.swarmId) return e
  const { swarmId: d, type: s } = m,
    t = { ...e.unknownMemberPresence },
    n = t[d]
  return s === r.REMOVE_MEMBER
    ? (n && delete t[d], { ...e, unknownMemberPresence: t })
    : s !== r.REMOVE_STREAM || a(m, n)
      ? { ...e, unknownMemberPresence: { ...t, [d]: [...(n || []), m] } }
      : e
}
export const removeCallMemberStreamReducer = (e, { payload: r }) => {
  const { swarmId: m, streamId: d, streamName: a } = r,
    s = {
      ...e.presenceBySwarmId[m],
      ...(e.presenceBySwarmId[m].streamByName && {
        streamByName: { ...e.presenceBySwarmId[m].streamByName },
      }),
    }
  return s.streamByName?.[a]?.streamId === d
    ? (delete s.streamByName[a], { ...e, presenceBySwarmId: { ...e.presenceBySwarmId, [m]: s } })
    : e
}
export const addCallMemberStreamReducer = (e, { payload: r }) => {
  const { memberId: m, swarmId: a, streamId: s, streamName: t } = r
  let {
    presenceBySwarmId: n,
    presenceMemberSwarmIds: c,
    presenceMemberIds: o,
    presenceSwarmByMemberId: I,
  } = e
  return (
    n[a] ||
      ((n = { ...n, [a]: d({ memberId: m, swarmId: a }) }),
      (c = [...c, a]),
      o.includes(m) || (o = [...o, m]),
      (I = { ...I, [m]: a })),
    {
      ...e,
      presenceMemberSwarmIds: c,
      presenceMemberIds: o,
      presenceSwarmByMemberId: I,
      presenceBySwarmId: {
        ...n,
        [a]: {
          ...n[a],
          streamByName: { ...n[a].streamByName, [t]: { streamId: s, streamName: t } },
        },
      },
    }
  )
}
export const removeCallMemberIdReducer = (e, { payload: r }) => {
  const { memberId: m, swarmId: d } = r || {}
  if (e.presenceBySwarmId[d]) {
    const r = Object.values(e.presenceBySwarmId).filter((e) => e.memberId === m).length,
      a = { ...e.presenceBySwarmId }
    delete a[d]
    const t = 1 === r
    let { presenceSwarmByMemberId: n } = e
    return (
      t && ((n = { ...n }), delete n[m]),
      {
        ...e,
        presenceBySwarmId: a,
        presenceMemberSwarmIds: e.presenceMemberSwarmIds.filter((e) => e !== d),
        presencesSortedByActivity: s(e, d),
        presenceMemberIds: t ? e.presenceMemberIds.filter((e) => e !== m) : e.presenceMemberIds,
        presenceSwarmByMemberId: n,
      }
    )
  }
  return e
}
export const addCallMemberIdReducer = (e, { payload: r }) => {
  const { memberId: m, swarmId: a } = r || {},
    s = e.unknownMemberPresence[a] ? { ...e.unknownMemberPresence } : e.unknownMemberPresence
  let {
      presenceBySwarmId: n,
      presenceMemberSwarmIds: c,
      presencesSortedByActivity: o,
      presenceMemberIds: I,
      presenceSwarmByMemberId: y,
    } = e,
    p = n[a]
  return (
    p ||
      ((p = d({ memberId: m, swarmId: a })),
      (n = { ...n, [a]: p }),
      (c = [...c, a]),
      (o = t(e, a)),
      I.includes(m) || (I = [...I, m]),
      (y = { ...y, [m]: a })),
    e.unknownMemberPresence[a] && delete s[a],
    {
      ...e,
      presenceBySwarmId: n,
      presenceMemberSwarmIds: c,
      presencesSortedByActivity: o,
      presenceMemberIds: I,
      presenceSwarmByMemberId: y,
      unknownMemberPresence: s,
    }
  )
}
export const updateCallRemoteMediaReducer = (r, { payload: d }) => {
  const { memberId: a, swarmId: s, audioMuted: n, videoMuted: c, streamName: o, streamId: I } = d
  let y = r.mediaBySwarmId[s] || m({ memberId: a, swarmId: s }),
    { presencesSortedByActivity: p } = r
  ;((y = { ...y, streamByName: { ...y.streamByName, [o]: { id: I } } }),
    o === e.CAMERA &&
      (n && y.audioError && delete y.audioError,
      (p = t(r, s, n, c)),
      (y.isAudioMuted = n),
      (y.isVideoMuted = c)))
  const w = r.connectedMemberIds?.[a] ? r.connectedMemberIds : { ...r.connectedMemberIds, [a]: !0 }
  return {
    ...r,
    presencesSortedByActivity: p,
    connectedMemberIds: w,
    mediaBySwarmId: { ...r.mediaBySwarmId, [s]: y },
  }
}
export const removeCallRemoteMediaReducer = (r, { payload: m }) => {
  const { swarmId: d, streamName: a, streamId: s } = m
  if (!d || !a || !s) return r
  let t = { ...r.mediaBySwarmId[d] }
  if (!t?.streamByName || !t.streamByName[a]) return r
  if (t.streamByName[a].id !== s) return r
  if (Object.keys(t.streamByName).length > 1)
    return (
      (t = { ...t, streamByName: { ...t.streamByName } }),
      delete t.streamByName[a],
      a === e.CAMERA && (delete t.audioError, delete t.isAudioMuted, delete t.isVideoMuted),
      { ...r, mediaBySwarmId: { ...r.mediaBySwarmId, [d]: t } }
    )
  const n = { ...r.mediaBySwarmId }
  return (delete n[d], { ...r, mediaBySwarmId: n })
}