keet-deobfuscated / @holepunchto / keet-store / store / call / call-stream.saga.js

import {
  fork as e,
  race as a,
  put as r,
  takeEvery as m,
  take as t,
  select as o,
  spawn as d,
} from "redux-saga/effects"
import { channelFromReadable as l } from "../lib"
import { getCallApi as s } from "../../backend"
import { taskErrorSaga as c } from "../error"
import { getCallPresenceState as i } from "./call.reducer"
import { updateCallRemoteMedia as I, removeCallRemoteMedia as n } from "./call.action"
import { getCallSettingsState as f } from "./call-settings.reducer"
import { removeMyStreams as y } from "./call-settings.action"
import { addCallMemberStream as u, isStreamRemovedPresenceData as S } from "./call-presence.action"
export function* cleanupMyStreams() {
  const { cameraStreamId: e, screenStreamId: a } = yield o(f)
  if (e || a)
    try {
      ;(e && (yield d(() => s().local.closeStream(e))),
        a && (yield d(() => s().local.closeStream(a))),
        yield r(y()))
    } catch (e) {
      yield c("callCleanupMyStreams", e)
    }
}
export function* callRemoteStreamSaga({
  callId: e,
  streamName: m,
  streamId: o,
  memberId: d,
  swarmId: i,
}) {
  let f
  yield r(
    I({ memberId: d, swarmId: i, audioMuted: !0, videoMuted: !0, streamName: m, streamId: o }),
  )
  const y = l(s().subscribeRemoteStream(e, o), {
    onError: (e) => {
      f = e
    },
  })
  try {
    for (;;) {
      const [e, l] = yield a([t(y), t(S({ swarmId: i, streamId: o }))])
      if (l) break
      if (e) {
        const { audioMuted: a, videoMuted: t } = e
        yield r(
          I({ memberId: d, swarmId: i, audioMuted: a, videoMuted: t, streamName: m, streamId: o }),
        )
      }
    }
  } catch (e) {
    yield c("callRemoteStreamSaga", e)
  } finally {
    ;(y && (y.close(), yield r(n({ swarmId: i, streamName: m, streamId: o }))),
      f && (yield c("callRemoteStreamSaga", f)))
  }
}
export function* callRemoteStreamManager({ callId: a }) {
  const r = yield o(i)
  for (const m of Object.values(r)) {
    const { memberId: r, swarmId: t, streamByName: o } = m
    for (const { streamId: m, streamName: d } of Object.values(o))
      yield e(callRemoteStreamSaga, {
        callId: a,
        memberId: r,
        swarmId: t,
        streamId: m,
        streamName: d,
      })
  }
  yield m(u, function* (r) {
    const { memberId: m, swarmId: t, streamId: o, streamName: d } = r.payload
    yield e(callRemoteStreamSaga, {
      callId: a,
      memberId: m,
      swarmId: t,
      streamId: o,
      streamName: d,
    })
  })
}