@signalwire/js 3.29.2 → 4.0.0-beta.1

package/src/video/workers/memberListUpdatedWorker.ts

@@ -1,217 +0,0 @@
-import {
-  sagaEffects,
-  SagaIterator,
-  SDKWorker,
-  toSyntheticEvent,
-  validateEventsToSubscribe,
-  toInternalEventName,
-  SwEventChannel,
-  InternalVideoMemberEntity,
-  InternalVideoMemberUpdatedEvent,
-  VideoMemberJoinedEvent,
-  VideoMemberLeftEvent,
-  VideoMemberUpdatedEvent,
-  InternalVideoRoomJoinedEvent,
-  MapToPubSubShape,
-} from '@signalwire/core'
-import type { VideoMemberListUpdatedParams } from '../../utils/interfaces'
-import { VideoRoomSession } from '../VideoRoomSession'
-
-const noop = () => {}
-
-const EXTERNAL_MEMBER_LIST_UPDATED_EVENT = 'memberList.updated'
-
-const INTERNAL_MEMBER_LIST_UPDATED_EVENT = toInternalEventName({
-  event: EXTERNAL_MEMBER_LIST_UPDATED_EVENT,
-})
-
-const SYNTHETIC_MEMBER_LIST_UPDATED_EVENT = toSyntheticEvent(
-  INTERNAL_MEMBER_LIST_UPDATED_EVENT
-)
-
-/**
- * List of action types this worker cares about.
- */
-type MemberListUpdatedTargetActions = MapToPubSubShape<
-  | InternalVideoRoomJoinedEvent
-  | InternalVideoMemberUpdatedEvent
-  | VideoMemberJoinedEvent
-  | VideoMemberLeftEvent
-  | VideoMemberUpdatedEvent
->
-
-const MEMBER_LIST_EVENTS: Array<MemberListUpdatedTargetActions['type']> = [
-  /** Alias to `video.room.subscribed` */
-  'video.room.joined',
-  'video.member.joined',
-  'video.member.left',
-  'video.member.updated',
-]
-
-type MemberList = Map<string, InternalVideoMemberEntity>
-
-const isMemberListEvent = (
-  event: string
-): event is MemberListUpdatedTargetActions['type'] => {
-  // @ts-expect-error
-  return MEMBER_LIST_EVENTS.includes(event)
-}
-
-const getMemberListEventsToSubscribe = (
-  subscriptions: MemberListUpdatedTargetActions['type'][]
-) => {
-  return validateEventsToSubscribe(MEMBER_LIST_EVENTS).filter((event) => {
-    return !subscriptions.includes(event)
-  })
-}
-
-const shouldHandleMemberList = (subscriptions: string[]) => {
-  return subscriptions.some((event) =>
-    event.includes(EXTERNAL_MEMBER_LIST_UPDATED_EVENT)
-  )
-}
-
-const getMembersFromAction = (action: MemberListUpdatedTargetActions) => {
-  if (action.type === 'video.room.joined') {
-    return action.payload.room_session.members
-  }
-
-  return [action.payload.member]
-}
-
-export const getUpdatedMembers = ({
-  action,
-  memberList,
-}: {
-  action: MemberListUpdatedTargetActions
-  memberList: MemberList
-}) => {
-  const actionMembers = getMembersFromAction(action)
-
-  switch (action.type) {
-    case 'video.member.left':
-      actionMembers.forEach((member: InternalVideoMemberEntity) => {
-        memberList.delete(member.id)
-      })
-      break
-    default:
-      actionMembers.forEach((member: InternalVideoMemberEntity) => {
-        memberList.set(member.id, member)
-      })
-  }
-
-  return Array.from(memberList.values())
-}
-
-const initMemberListSubscriptions = (
-  room: VideoRoomSession,
-  subscriptions: MemberListUpdatedTargetActions['type'][]
-) => {
-  const events = getMemberListEventsToSubscribe(subscriptions)
-
-  events.forEach((event) => {
-    /**
-     * Params to `subscribe` come from the event handlers
-     * the user has attached so to make sure we subscribe to
-     * all the appropiate events needed for
-     * `memberList.updated` to work, we must subscribe to
-     * the required events. We don't need to act upon the
-     * event (that's why we attach a `noop`), just to
-     * register it (`subscribe` gets its values from
-     * `BaseComponent.getSubscriptions`, which gets
-     * populated by each of the  event handlers the user
-     * attached).
-     */
-    room.once(event as any, noop)
-  })
-
-  /**
-   * This handler will act as a simple bridge between
-   * synthetic events and external events.
-   */
-  const eventBridgeHandler = ({ members }: VideoMemberListUpdatedParams) => {
-    room.emit(EXTERNAL_MEMBER_LIST_UPDATED_EVENT, { members })
-  }
-
-  // @ts-expect-error
-  room.on(SYNTHETIC_MEMBER_LIST_UPDATED_EVENT, eventBridgeHandler)
-
-  /**
-   * Any events attached by the saga should be specified
-   * here so it can be cleaned up when needed.
-   */
-  const cleanup = () => {
-    // @ts-expect-error
-    room.off(SYNTHETIC_MEMBER_LIST_UPDATED_EVENT, eventBridgeHandler)
-  }
-
-  return {
-    cleanup,
-  }
-}
-
-function* membersListUpdatedWatcher({
-  swEventChannel,
-  instance,
-}: {
-  swEventChannel: SwEventChannel
-  instance: any
-}): SagaIterator {
-  const memberList: MemberList = new Map()
-
-  function* worker(pubSubAction: MemberListUpdatedTargetActions) {
-    const roomSessionId =
-      pubSubAction.type === 'video.room.joined'
-        ? pubSubAction.payload.room_session.id
-        : pubSubAction.payload.room_session_id
-
-    const members = getUpdatedMembers({ action: pubSubAction, memberList })
-    const memberListPayload = {
-      /**
-       * At this point it's needed to send the
-       * `room_session_id` so the pubSubSaga can properly
-       * infer the namespace for emitting the events to the
-       * appropiate room.
-       */
-      room_session_id: roomSessionId,
-      members,
-    }
-
-    instance.emit(SYNTHETIC_MEMBER_LIST_UPDATED_EVENT, memberListPayload)
-  }
-
-  while (true) {
-    const pubSubAction: MemberListUpdatedTargetActions = yield sagaEffects.take(
-      swEventChannel,
-      ({ type }: any) => {
-        return isMemberListEvent(type)
-      }
-    )
-
-    yield sagaEffects.fork(worker, pubSubAction)
-  }
-}
-
-export const memberListUpdatedWorker: SDKWorker<VideoRoomSession> =
-  function* membersChangedWorker({
-    channels: { swEventChannel },
-    instance,
-  }): SagaIterator {
-    // @ts-expect-error
-    const subscriptions = instance.getSubscriptions()
-
-    if (!shouldHandleMemberList(subscriptions)) {
-      return
-    }
-
-    const { cleanup } = initMemberListSubscriptions(instance, subscriptions)
-
-    yield sagaEffects.fork(membersListUpdatedWatcher, {
-      swEventChannel,
-      instance,
-    })
-
-    instance.once('destroy', () => {
-      cleanup()
-    })
-  }

package/src/video/workers/videoPlaybackWorker.ts

@@ -1,54 +0,0 @@
-import {
-  getLogger,
-  SagaIterator,
-  MapToPubSubShape,
-  RoomSessionPlayback,
-  Rooms,
-  VideoPlaybackEvent,
-  VideoPlaybackEventNames,
-  stripNamespacePrefix,
-} from '@signalwire/core'
-import { VideoWorkerParams } from './videoWorker'
-
-export const videoPlaybackWorker = function* (
-  options: VideoWorkerParams<MapToPubSubShape<VideoPlaybackEvent>>
-): SagaIterator {
-  getLogger().trace('videoPlaybackWorker started')
-  const {
-    instance: roomSession,
-    action: { type, payload },
-    instanceMap: { get, set, remove },
-  } = options
-
-  // For now, we are not storing the RoomSession object in the instance map
-
-  let playbackInstance = get<RoomSessionPlayback>(payload.playback.id)
-  if (!playbackInstance) {
-    playbackInstance = Rooms.createRoomSessionPlaybackObject({
-      store: roomSession.store,
-      payload,
-    })
-  } else {
-    playbackInstance.setPayload(payload)
-  }
-  set<RoomSessionPlayback>(payload.playback.id, playbackInstance)
-
-  const event = stripNamespacePrefix(type) as VideoPlaybackEventNames
-
-  switch (type) {
-    case 'video.playback.started':
-    case 'video.playback.updated': {
-      roomSession.emit(event, playbackInstance)
-      break
-    }
-    case 'video.playback.ended':
-      roomSession.emit(event, playbackInstance)
-      remove<RoomSessionPlayback>(payload.playback.id)
-      break
-    default:
-      getLogger().warn(`Unknown video.stream event: "${type}"`)
-      break
-  }
-
-  getLogger().trace('videoPlaybackWorker ended')
-}

package/src/video/workers/videoRecordWorker.ts

@@ -1,54 +0,0 @@
-import {
-  getLogger,
-  SagaIterator,
-  MapToPubSubShape,
-  RoomSessionRecording,
-  Rooms,
-  VideoRecordingEvent,
-  VideoRecordingEventNames,
-  stripNamespacePrefix,
-} from '@signalwire/core'
-import { VideoWorkerParams } from './videoWorker'
-
-export const videoRecordWorker = function* (
-  options: VideoWorkerParams<MapToPubSubShape<VideoRecordingEvent>>
-): SagaIterator {
-  getLogger().trace('videoRecordWorker started')
-  const {
-    instance: roomSession,
-    action: { type, payload },
-    instanceMap: { get, set, remove },
-  } = options
-
-  // For now, we are not storing the RoomSession object in the instance map
-
-  let recordingInstance = get<RoomSessionRecording>(payload.recording.id)
-  if (!recordingInstance) {
-    recordingInstance = Rooms.createRoomSessionRecordingObject({
-      store: roomSession.store,
-      payload,
-    })
-  } else {
-    recordingInstance.setPayload(payload)
-  }
-  set<RoomSessionRecording>(payload.recording.id, recordingInstance)
-
-  const event = stripNamespacePrefix(type) as VideoRecordingEventNames
-
-  switch (type) {
-    case 'video.recording.started':
-    case 'video.recording.updated': {
-      roomSession.emit(event, recordingInstance)
-      break
-    }
-    case 'video.recording.ended':
-      roomSession.emit(event, recordingInstance)
-      remove<RoomSessionRecording>(payload.recording.id)
-      break
-    default:
-      getLogger().warn(`Unknown video.stream event: "${type}"`)
-      break
-  }
-
-  getLogger().trace('videoRecordWorker ended')
-}

package/src/video/workers/videoStreamWorker.ts

@@ -1,48 +0,0 @@
-import {
-  getLogger,
-  SagaIterator,
-  MapToPubSubShape,
-  VideoStreamEvent,
-  RoomSessionStream,
-  Rooms,
-} from '@signalwire/core'
-import { VideoWorkerParams } from './videoWorker'
-
-export const videoStreamWorker = function* (
-  options: VideoWorkerParams<MapToPubSubShape<VideoStreamEvent>>
-): SagaIterator {
-  getLogger().trace('videoStreamWorker started')
-  const {
-    instance: roomSession,
-    action: { type, payload },
-    instanceMap: { get, set, remove },
-  } = options
-
-  // For now, we are not storing the RoomSession object in the instance map
-
-  let streamInstance = get<RoomSessionStream>(payload.stream.id)
-  if (!streamInstance) {
-    streamInstance = Rooms.createRoomSessionStreamObject({
-      store: roomSession.store,
-      payload,
-    })
-  } else {
-    streamInstance.setPayload(payload)
-  }
-  set<RoomSessionStream>(payload.stream.id, streamInstance)
-
-  switch (type) {
-    case 'video.stream.started':
-      roomSession.emit('stream.started', streamInstance)
-      break
-    case 'video.stream.ended':
-      roomSession.emit('stream.ended', streamInstance)
-      remove<RoomSessionStream>(payload.stream.id)
-      break
-    default:
-      getLogger().warn(`Unknown video.stream event: "${type}"`)
-      break
-  }
-
-  getLogger().trace('videoStreamWorker ended')
-}

package/src/video/workers/videoWorker.ts

@@ -1,113 +0,0 @@
-import {
-  SDKActions,
-  SDKWorker,
-  SagaIterator,
-  getLogger,
-  sagaEffects,
-  SDKWorkerParams,
-  MemberPosition,
-  stripNamespacePrefix,
-  VideoAction,
-  VideoRoomDeviceEventNames,
-  BaseConnectionState,
-} from '@signalwire/core'
-import { videoStreamWorker } from './videoStreamWorker'
-import { videoRecordWorker } from './videoRecordWorker'
-import { videoPlaybackWorker } from './videoPlaybackWorker'
-import { VideoRoomSessionConnection } from '../VideoRoomSession'
-import { MediaEventNames } from '@signalwire/webrtc'
-
-export type VideoWorkerParams<T> =
-  SDKWorkerParams<VideoRoomSessionConnection> & {
-    action: T
-  }
-
-export const videoWorker: SDKWorker<VideoRoomSessionConnection> = function* (
-  options
-): SagaIterator {
-  getLogger().trace('videoWorker started')
-
-  const { channels, instance: roomSession } = options
-  const { swEventChannel } = channels
-
-  function* worker(action: VideoAction) {
-    const { type, payload } = action
-
-    switch (type) {
-      case 'video.room.subscribed':
-        yield sagaEffects.fork(MemberPosition.memberPositionWorker, {
-          ...options,
-          instance: roomSession,
-          initialState: payload,
-        })
-        return
-      case 'video.playback.started':
-      case 'video.playback.updated':
-      case 'video.playback.ended':
-        yield sagaEffects.fork(videoPlaybackWorker, {
-          action,
-          ...options,
-        })
-        return // Return since we don't need to handle the raw event for this
-      case 'video.recording.started':
-      case 'video.recording.updated':
-      case 'video.recording.ended':
-        yield sagaEffects.fork(videoRecordWorker, {
-          action,
-          ...options,
-        })
-        return
-      case 'video.stream.ended':
-      case 'video.stream.started':
-        yield sagaEffects.fork(videoStreamWorker, {
-          action,
-          ...options,
-        })
-        return
-      case 'video.room.audience_count': {
-        roomSession.emit('room.audienceCount', payload)
-        return
-      }
-      case 'video.member.talking': {
-        const { member } = payload
-        if ('talking' in member) {
-          const suffix = member.talking ? 'started' : 'ended'
-          roomSession.emit(`member.talking.${suffix}`, payload)
-
-          // Keep for backwards compat.
-          const deprecatedSuffix = member.talking ? 'start' : 'stop'
-          roomSession.emit(`member.talking.${deprecatedSuffix}`, payload)
-        }
-        break // Break here since we do need the raw event sent to the client
-      }
-      case 'video.layout.changed': {
-        // Upsert the layout event which is needed for buildVideoElement
-        roomSession.currentLayoutEvent = action.payload
-        break
-      }
-      default:
-        break
-    }
-
-    const event = stripNamespacePrefix(type, 'video') as
-      | VideoRoomDeviceEventNames
-      | MediaEventNames
-      | BaseConnectionState
-    roomSession.emit(event, payload)
-  }
-
-  const isVideoEvent = (action: SDKActions) => {
-    return action.type.startsWith('video.')
-  }
-
-  while (true) {
-    const action: VideoAction = yield sagaEffects.take(
-      swEventChannel,
-      isVideoEvent
-    )
-
-    yield sagaEffects.fork(worker, action)
-  }
-
-  getLogger().trace('videoWorker ended')
-}

package/src/webrtc.ts

@@ -1,33 +0,0 @@
-export {
-  getDevices,
-  getCameraDevices,
-  getMicrophoneDevices,
-  getSpeakerDevices,
-  getDevicesWithPermissions,
-  getCameraDevicesWithPermissions,
-  getMicrophoneDevicesWithPermissions,
-  getSpeakerDevicesWithPermissions,
-  checkPermissions,
-  checkCameraPermissions,
-  checkMicrophonePermissions,
-  checkSpeakerPermissions,
-  requestPermissions,
-  createDeviceWatcher,
-  createCameraDeviceWatcher,
-  createMicrophoneDeviceWatcher,
-  createSpeakerDeviceWatcher,
-  supportsMediaDevices,
-  supportsGetUserMedia,
-  supportsGetDisplayMedia,
-  getUserMedia,
-  getDisplayMedia,
-  enumerateDevices,
-  enumerateDevicesByKind,
-  getSupportedConstraints,
-  supportsMediaOutput,
-  setMediaElementSinkId,
-  stopStream,
-  stopTrack,
-  createMicrophoneAnalyzer,
-} from '@signalwire/webrtc'
-export type { MicrophoneAnalyzer } from '@signalwire/webrtc'