@signalwire/js 3.29.2 → 4.0.0-beta.0

package/src/video/VideoRoomSession.ts

@@ -1,304 +0,0 @@
-import {
-  BaseComponentContract,
-  BaseConnectionContract,
-  connect,
-  EventEmitter,
-  extendComponent,
-  Rooms,
-  validateEventsToSubscribe,
-  VideoAuthorization,
-  VideoLayoutChangedEventParams,
-} from '@signalwire/core'
-import { BaseConnectionOptions } from '@signalwire/webrtc'
-import {
-  BaseRoomSessionConnection,
-  BaseRoomSessionOptions,
-} from '../BaseRoomSession'
-import {
-  RoomSessionDevice,
-  RoomSessionDeviceAPI,
-  RoomSessionDeviceConnection,
-  RoomSessionDeviceEvents,
-} from '../RoomSessionDevice'
-import * as workers from './workers'
-import {
-  AddCameraOptions,
-  AddDeviceOptions,
-  AddMicrophoneOptions,
-  CreateScreenShareObjectOptions,
-  VideoRoomSessionMethods,
-  VideoRoomSessionEvents,
-  VideoRoomSessionContract,
-  BaseRoomSessionContract,
-} from '../utils/interfaces'
-
-export interface VideoRoomSession
-  extends VideoRoomSessionContract,
-    VideoRoomSessionMethods,
-    BaseRoomSessionContract,
-    BaseConnectionContract<VideoRoomSessionEvents>,
-    BaseComponentContract {}
-
-export interface VideoRoomSessionOptions extends BaseRoomSessionOptions {}
-
-export class VideoRoomSessionConnection
-  extends BaseRoomSessionConnection<VideoRoomSessionEvents>
-  implements VideoRoomSessionContract
-{
-  private _deviceList = new Set<RoomSessionDevice>()
-  private _currentLayoutEvent: VideoLayoutChangedEventParams
-
-  constructor(options: VideoRoomSessionOptions) {
-    super(options)
-
-    this.initWorker()
-  }
-
-  set currentLayoutEvent(event: VideoLayoutChangedEventParams) {
-    this._currentLayoutEvent = event
-  }
-
-  get currentLayoutEvent() {
-    return this._currentLayoutEvent
-  }
-
-  get currentLayout() {
-    return this._currentLayoutEvent?.layout
-  }
-
-  get currentPosition() {
-    return this._currentLayoutEvent?.layout.layers.find(
-      (layer) => layer.member_id === this.memberId
-    )?.position
-  }
-
-  get deviceList() {
-    return Array.from(this._deviceList)
-  }
-
-  get interactivityMode() {
-    return this.select(({ session }) => {
-      const { authorization } = session
-      return (authorization as VideoAuthorization)?.join_as ?? ''
-    })
-  }
-
-  get permissions() {
-    return this.select(({ session }) => {
-      const { authorization } = session
-      return (authorization as VideoAuthorization)?.room?.scopes ?? []
-    })
-  }
-
-  private initWorker() {
-    this.runWorker('videoWorker', {
-      worker: workers.videoWorker,
-    })
-  }
-
-  /** @internal */
-  protected override getSubscriptions() {
-    const eventNamesWithPrefix = this.eventNames().map((event) => {
-      return `video.${String(event)}`
-    })
-    return validateEventsToSubscribe(
-      eventNamesWithPrefix
-    ) as EventEmitter.EventNames<{}>[]
-  }
-
-  /** @internal */
-  protected _finalize() {
-    this._deviceList.clear()
-
-    super._finalize()
-  }
-
-  /** @internal */
-  override async hangup(id?: string) {
-    this._deviceList.forEach((device) => {
-      device.leave()
-    })
-
-    return super.hangup(id)
-  }
-
-  join() {
-    return super.invite<VideoRoomSession>()
-  }
-
-  /**
-   * @deprecated Use {@link getLayouts} instead. `getLayoutList` will
-   * be removed in v3.0.0
-   */
-  getLayoutList() {
-    // @ts-expect-error
-    return this.getLayouts()
-  }
-
-  /**
-   * @deprecated Use {@link getMembers} instead. `getMemberList` will
-   * be removed in v3.0.0
-   */
-  getMemberList() {
-    // @ts-expect-error
-    return this.getMembers()
-  }
-
-  /** @deprecated Use {@link startScreenShare} instead. */
-  async createScreenShareObject(opts: CreateScreenShareObjectOptions = {}) {
-    return this.startScreenShare(opts)
-  }
-
-  /**
-   * Allow to add a camera to the room.
-   */
-  addCamera(opts: AddCameraOptions = {}) {
-    const { autoJoin = true, ...video } = opts
-    return this.addDevice({
-      autoJoin,
-      video,
-    })
-  }
-
-  /**
-   * Allow to add a microphone to the room.
-   */
-  addMicrophone(opts: AddMicrophoneOptions = {}) {
-    const { autoJoin = true, ...audio } = opts
-    return this.addDevice({
-      autoJoin,
-      audio,
-    })
-  }
-
-  /**
-   * Allow to add additional devices to the room like cameras or microphones.
-   */
-  async addDevice(opts: AddDeviceOptions = {}) {
-    return new Promise<RoomSessionDevice>(async (resolve, reject) => {
-      const { autoJoin = true, audio = false, video = false } = opts
-      if (!audio && !video) {
-        throw new TypeError(
-          'At least one of `audio` or `video` must be requested.'
-        )
-      }
-
-      const options: BaseConnectionOptions = {
-        ...this.options,
-        localStream: undefined,
-        remoteStream: undefined,
-        audio,
-        video,
-        additionalDevice: true,
-        recoverCall: false,
-        userVariables: {
-          ...(this.options?.userVariables || {}),
-          memberCallId: this.callId,
-          memberId: this.memberId,
-        },
-      }
-
-      const roomDevice = connect<
-        RoomSessionDeviceEvents,
-        RoomSessionDeviceConnection,
-        RoomSessionDevice
-      >({
-        store: this.store,
-        Component: RoomSessionDeviceAPI,
-      })(options)
-
-      roomDevice.once('destroy', () => {
-        roomDevice.emit('room.left')
-        this._deviceList.delete(roomDevice)
-      })
-
-      try {
-        roomDevice.runWorker('childMemberJoinedWorker', {
-          worker: workers.childMemberJoinedWorker,
-          onDone: () => resolve(roomDevice),
-          onFail: reject,
-          initialState: {
-            parentId: this.memberId,
-          },
-        })
-
-        this._deviceList.add(roomDevice)
-        if (autoJoin) {
-          return await roomDevice.join()
-        }
-        return resolve(roomDevice)
-      } catch (error) {
-        this.logger.error('RoomDevice Error', error)
-        reject(error)
-      }
-    })
-  }
-}
-
-export const VideoRoomSessionAPI = extendComponent<
-  VideoRoomSessionConnection,
-  VideoRoomSessionMethods
->(VideoRoomSessionConnection, {
-  audioMute: Rooms.audioMuteMember,
-  audioUnmute: Rooms.audioUnmuteMember,
-  videoMute: Rooms.videoMuteMember,
-  videoUnmute: Rooms.videoUnmuteMember,
-  deaf: Rooms.deafMember,
-  undeaf: Rooms.undeafMember,
-  setInputVolume: Rooms.setInputVolumeMember,
-  setOutputVolume: Rooms.setOutputVolumeMember,
-  setMicrophoneVolume: Rooms.setInputVolumeMember,
-  setSpeakerVolume: Rooms.setOutputVolumeMember,
-  setInputSensitivity: Rooms.setInputSensitivityMember,
-  removeMember: Rooms.removeMember,
-  removeAllMembers: Rooms.removeAllMembers,
-  getMembers: Rooms.getMembers,
-  getLayouts: Rooms.getLayouts,
-  setLayout: Rooms.setLayout,
-  setPositions: Rooms.setPositions,
-  setMemberPosition: Rooms.setMemberPosition,
-  hideVideoMuted: Rooms.hideVideoMuted,
-  showVideoMuted: Rooms.showVideoMuted,
-  getRecordings: Rooms.getRecordings,
-  startRecording: Rooms.startRecording,
-  getPlaybacks: Rooms.getPlaybacks,
-  play: Rooms.play,
-  setHideVideoMuted: Rooms.setHideVideoMuted,
-  getMeta: Rooms.getMeta,
-  setMeta: Rooms.setMeta,
-  updateMeta: Rooms.updateMeta,
-  deleteMeta: Rooms.deleteMeta,
-  getMemberMeta: Rooms.getMemberMeta,
-  setMemberMeta: Rooms.setMemberMeta,
-  updateMemberMeta: Rooms.updateMemberMeta,
-  deleteMemberMeta: Rooms.deleteMemberMeta,
-  promote: Rooms.promote,
-  demote: Rooms.demote,
-  getStreams: Rooms.getStreams,
-  startStream: Rooms.startStream,
-  lock: Rooms.lock,
-  unlock: Rooms.unlock,
-  setRaisedHand: Rooms.setRaisedHand,
-  setPrioritizeHandraise: Rooms.setPrioritizeHandraise,
-})
-
-export const isVideoRoomSession = (room: unknown): room is VideoRoomSession => {
-  return room instanceof VideoRoomSessionConnection
-}
-
-/** @internal */
-export const createVideoRoomSessionObject = (
-  params: VideoRoomSessionOptions
-): VideoRoomSession => {
-  const room = connect<
-    VideoRoomSessionEvents,
-    VideoRoomSessionConnection,
-    VideoRoomSession
-  >({
-    store: params.store,
-    customSagas: params.customSagas,
-    Component: VideoRoomSessionAPI,
-  })(params)
-
-  return room
-}

package/src/video/index.ts

@@ -1,43 +0,0 @@
-import { createRoomObject, Room } from '../createRoomObject'
-import { createClient } from '../createClient'
-import { joinRoom } from '../joinRoom'
-import { MakeRoomOptions } from '../Client'
-import { RoomSession, RoomSessionOptions } from './RoomSession'
-import { RoomSessionDevice, RoomDevice } from '../RoomSessionDevice'
-import {
-  RoomSessionScreenShare,
-  RoomScreenShare,
-} from '../RoomSessionScreenShare'
-
-export {
-  RoomSession,
-  RoomSessionDevice,
-  RoomSessionScreenShare,
-  // Just to keep backwards compatibility.
-  createRoomObject,
-  joinRoom,
-  Room,
-  RoomDevice,
-  RoomScreenShare,
-  createClient,
-}
-
-/** @ignore */
-export type { MakeRoomOptions, RoomSessionOptions }
-
-/** @ignore */
-export type {
-  DeprecatedMemberUpdatableProps,
-  DeprecatedVideoMemberHandlerParams,
-  VideoMemberHandlerParams,
-  VideoMemberListUpdatedParams,
-} from '../utils/interfaces'
-
-export type { CreateRoomObjectOptions } from '../createRoomObject'
-
-export type {
-  RoomSessionRecording,
-  RoomSessionPlayback,
-} from '@signalwire/core'
-
-export { VideoRoomSession, isVideoRoomSession } from './VideoRoomSession'

package/src/video/workers/childMemberJoinedWorker.test.ts

@@ -1,99 +0,0 @@
-import { testUtils, componentActions } from '@signalwire/core'
-import { expectSaga } from 'redux-saga-test-plan'
-import { childMemberJoinedWorker } from './childMemberJoinedWorker'
-
-const { createSwEventChannel, createSessionChannel } = testUtils
-
-describe('childMemberJoinedWorker', () => {
-  it('should handle video.member.joined with parent_id', () => {
-    const parentId = 'd815d293-f8d0-49e8-aec2-3a4cc3729af8'
-    const memberId = 'b8912cc5-4248-4345-b53c-d53b2761748d'
-    let runSaga = true
-    const swEventChannel = createSwEventChannel()
-    const sessionChannel = createSessionChannel()
-    const session = {
-      connect: jest.fn(),
-    } as any
-    const getSession = jest.fn().mockImplementation(() => session)
-    const dispatchedActions: unknown[] = []
-    const defaultState = {
-      components: {
-        byId: {
-          [parentId]: {
-            id: parentId,
-            responses: {},
-            state: 'active',
-            remoteSDP: 'sdp',
-            nodeId: '4959db05-3dbb-41fa-ae1d-596854b665d0@',
-            roomId: '6e83849b-5cc2-4fc6-80ed-448113c8a426',
-            roomSessionId: '313bedbe-edc9-4653-b332-34fbf43e8289',
-            memberId: parentId,
-          },
-        },
-      },
-    }
-
-    return expectSaga(childMemberJoinedWorker, {
-      channels: {
-        swEventChannel,
-        sessionChannel,
-      },
-      instance: {
-        callId: 'callId',
-      } as any,
-      initialState: {
-        parentId,
-      },
-      instanceMap: {
-        get: jest.fn(),
-        set: jest.fn(),
-        remove: jest.fn(),
-        getAll: jest.fn(),
-        deleteAll: jest.fn(),
-      },
-      getSession,
-      runSaga: jest.fn(),
-    })
-      .withState(defaultState)
-      .provide([
-        {
-          take({ channel }, next) {
-            if (runSaga && channel === swEventChannel) {
-              runSaga = false
-
-              return {
-                type: 'video.member.joined',
-                payload: {
-                  room_session_id: '313bedbe-edc9-4653-b332-34fbf43e8289',
-                  room_id: '6e83849b-5cc2-4fc6-80ed-448113c8a426',
-                  member: {
-                    id: memberId,
-                    parent_id: parentId,
-                  },
-                },
-              }
-            } else if (runSaga === false) {
-              sessionChannel.close()
-            }
-            return next()
-          },
-          put(action, next) {
-            dispatchedActions.push(action)
-            return next()
-          },
-        },
-      ])
-      .put(
-        componentActions.upsert({
-          id: 'callId',
-          roomId: '6e83849b-5cc2-4fc6-80ed-448113c8a426',
-          roomSessionId: '313bedbe-edc9-4653-b332-34fbf43e8289',
-          memberId,
-        })
-      )
-      .silentRun()
-      .finally(() => {
-        expect(dispatchedActions).toHaveLength(1)
-      })
-  })
-})

package/src/video/workers/childMemberJoinedWorker.ts

@@ -1,75 +0,0 @@
-import {
-  getLogger,
-  sagaEffects,
-  SagaIterator,
-  SDKWorker,
-  SDKActions,
-  MapToPubSubShape,
-  SDKWorkerHooks,
-  VideoMemberJoinedEvent,
-  componentSelectors,
-  componentActions,
-  type ReduxComponent,
-} from '@signalwire/core'
-
-import type { BaseConnection } from '@signalwire/webrtc'
-
-type ChildMemberJoinedWorkerOnDone = () => void
-type ChildMemberJoinedWorkerOnFail = (args: { error: Error }) => void
-
-export type ChildMemberJoinedWorkerHooks = SDKWorkerHooks<
-  ChildMemberJoinedWorkerOnDone,
-  ChildMemberJoinedWorkerOnFail
->
-
-export const childMemberJoinedWorker: SDKWorker<
-  BaseConnection<any>,
-  ChildMemberJoinedWorkerHooks
-> = function* (options): SagaIterator {
-  getLogger().trace('childMemberJoinedWorker started')
-  const { channels, instance, initialState, onDone, onFail } = options
-  const { swEventChannel } = channels
-  const { parentId } = initialState
-  if (!parentId) {
-    throw new Error('Missing parentId for childMemberJoinedWorker')
-  }
-
-  const action: MapToPubSubShape<VideoMemberJoinedEvent> =
-    yield sagaEffects.take(swEventChannel, (action: SDKActions) => {
-      if (action.type === 'video.member.joined') {
-        return action.payload.member.parent_id === parentId
-      }
-      return false
-    })
-
-  /**
-   * On video.member.joined with a parent_id, check if we are the
-   * owner of the object comparing parent_id in the state.
-   * If so update the state with the room values to update the
-   * object.
-   */
-  const { member } = action.payload
-  if (member?.parent_id) {
-    const byId: Record<string, ReduxComponent> = yield sagaEffects.select(
-      componentSelectors.getComponentsById
-    )
-    const parent = Object.values(byId).find((row) => {
-      return 'memberId' in row && row.memberId === member.parent_id
-    })
-    if (parent) {
-      yield sagaEffects.put(
-        componentActions.upsert({
-          id: instance.callId,
-          roomId: action.payload.room_id,
-          roomSessionId: action.payload.room_session_id,
-          memberId: member.id,
-        })
-      )
-
-      onDone?.()
-    } else {
-      onFail?.({ error: new Error('Unknown parent_id') })
-    }
-  }
-  getLogger().trace('childMemberJoinedWorker ended')
-}

package/src/video/workers/index.ts

@@ -1,6 +0,0 @@
-export * from './memberListUpdatedWorker'
-export * from './childMemberJoinedWorker'
-export * from './videoWorker'
-export * from './videoPlaybackWorker'
-export * from './videoRecordWorker'
-export * from './videoStreamWorker'