@signalwire/js 3.29.2 → 4.0.0-dev-20260220205014

package/src/utils/interfaces/video.ts

@@ -1,440 +0,0 @@
-import type {
-  Rooms,
-  VideoLayoutEventNames,
-  VideoRoomSessionEventNames,
-  VideoRoomEventParams,
-  InternalVideoMemberEntity,
-  InternalVideoMemberEntityUpdated,
-  VideoMemberEventNames,
-  MemberUpdated,
-  MemberUpdatedEventNames,
-  MemberTalkingEventNames,
-  VideoMemberTalkingEventParams,
-  RTCTrackEventName,
-  InternalVideoMemberUpdatableProps,
-  VideoRecordingEventNames,
-  VideoPlaybackEventNames,
-  RoomSessionRecording,
-  RoomSessionPlayback,
-  VideoRoomSessionContract as CoreVideoRoomSessionContract,
-  OnlyFunctionProperties,
-  MemberListUpdated,
-  VideoPositions,
-  RoomAudienceCount,
-  VideoRoomAudienceCountEventParams,
-  RoomLeft,
-  RoomLeftEventParams,
-  VideoStreamEventNames,
-  RoomSessionStream,
-  RoomJoined,
-  RoomSubscribed,
-  VideoRoomSubscribedEventParams,
-  VideoAuthorization,
-  VideoRoomDeviceUpdatedEventNames,
-  DeviceUpdatedEventParams,
-  VideoRoomDeviceDisconnectedEventNames,
-  DeviceDisconnectedEventParams,
-  VideoRoomDeviceEventNames,
-  VideoLayoutChangedEventParams,
-  VideoPosition,
-  BaseConnectionState,
-} from '@signalwire/core'
-import { INTERNAL_MEMBER_UPDATABLE_PROPS } from '@signalwire/core'
-import type { MediaEventNames } from '@signalwire/webrtc'
-import type { RoomSessionDevice } from '../../RoomSessionDevice'
-import type { RoomSessionScreenShare } from '../../RoomSessionScreenShare'
-import { RoomSession } from '../../video/RoomSession'
-
-/**
- * @privateRemarks
- * Every other package exposing a `VideoMemberEntity` is
- * transforming the server payload into something else, with
- * the most significant change being converting properties
- * from snake to camel case. The `js` package, on the other
- * hand, exposes the server payload pretty much as is (as of
- * v3) so what we consider internal (sdk and server) in
- * other packages is external (user facing) for `js`. Same
- * applies to `VideoMemberEntityUpdated` since it's just a
- * derived type.
- */
-type VideoMemberEntity = InternalVideoMemberEntity
-type VideoMemberEntityUpdated = InternalVideoMemberEntityUpdated
-
-const INTERNAL_MEMBER_UPDATED_EVENTS = Object.keys(
-  INTERNAL_MEMBER_UPDATABLE_PROPS
-).map((key) => {
-  return `member.updated.${
-    key as keyof InternalVideoMemberUpdatableProps
-  }` as const
-})
-/** @deprecated */
-export type DeprecatedMemberUpdatableProps =
-  (typeof INTERNAL_MEMBER_UPDATED_EVENTS)[number]
-/** @deprecated */
-export type DeprecatedVideoMemberHandlerParams = {
-  member: InternalVideoMemberEntity
-}
-export type VideoMemberHandlerParams = { member: VideoMemberEntity }
-export type VideoMemberUpdatedHandlerParams = {
-  member: VideoMemberEntityUpdated
-  room_id?: string
-  room_session_id?: string
-}
-export type VideoMemberListUpdatedParams = { members: VideoMemberEntity[] }
-
-/**
- * List of all the events a RoomObject can listen to
- */
-export type RoomEventNames =
-  | VideoRoomSessionEventNames
-  | VideoMemberEventNames
-  | VideoLayoutEventNames
-  | VideoRecordingEventNames
-  | VideoPlaybackEventNames
-  | VideoStreamEventNames
-  | RTCTrackEventName
-
-export type RoomSessionObjectEventsHandlerMap = Record<
-  VideoRoomDeviceEventNames,
-  (params: DeviceUpdatedEventParams) => void
-> &
-  Record<
-    VideoLayoutEventNames,
-    (params: VideoLayoutChangedEventParams) => void
-  > &
-  Record<
-    Exclude<
-      VideoMemberEventNames,
-      MemberUpdated | MemberUpdatedEventNames | MemberListUpdated
-    >,
-    (params: VideoMemberHandlerParams) => void
-  > &
-  Record<
-    Extract<VideoMemberEventNames, MemberUpdated | MemberUpdatedEventNames>,
-    (params: VideoMemberUpdatedHandlerParams) => void
-  > &
-  Record<
-    Extract<VideoMemberEventNames, MemberListUpdated>,
-    (params: VideoMemberListUpdatedParams) => void
-  > &
-  Record<
-    DeprecatedMemberUpdatableProps,
-    (params: DeprecatedVideoMemberHandlerParams) => void
-  > &
-  Record<
-    MemberTalkingEventNames,
-    (params: VideoMemberTalkingEventParams) => void
-  > &
-  Record<
-    Exclude<VideoRoomSessionEventNames, RoomLeft | RoomJoined | RoomSubscribed>,
-    (params: VideoRoomEventParams) => void
-  > &
-  Record<
-    RoomJoined | RoomSubscribed,
-    (params: VideoRoomSubscribedEventParams) => void
-  > &
-  Record<RoomLeft, (params?: RoomLeftEventParams) => void> &
-  Record<MediaEventNames, () => void> &
-  Record<
-    VideoRoomDeviceUpdatedEventNames,
-    (params: DeviceUpdatedEventParams) => void
-  > &
-  Record<
-    VideoRoomDeviceDisconnectedEventNames,
-    (params: DeviceDisconnectedEventParams) => void
-  > &
-  Record<
-    RoomAudienceCount,
-    (params: VideoRoomAudienceCountEventParams) => void
-  > &
-  Record<RTCTrackEventName, (event: RTCTrackEvent) => void> &
-  Record<VideoRecordingEventNames, (recording: RoomSessionRecording) => void> &
-  Record<VideoPlaybackEventNames, (recording: RoomSessionPlayback) => void> &
-  Record<BaseConnectionState, (params: RoomSession) => void> &
-  Record<VideoStreamEventNames, (stream: RoomSessionStream) => void>
-
-// @deprecated Please use {@link VideoRoomSessionEvents}
-export type RoomSessionObjectEvents = {
-  [k in keyof RoomSessionObjectEventsHandlerMap]: RoomSessionObjectEventsHandlerMap[k]
-}
-
-export type VideoRoomSessionEvents = {
-  [k in keyof RoomSessionObjectEventsHandlerMap]: RoomSessionObjectEventsHandlerMap[k]
-}
-
-export type StartScreenShareOptions = {
-  /** Whether the screen share object should automatically join the room */
-  autoJoin?: boolean
-  /** Audio constraints to use when joining the room. Default: `true`. */
-  audio?: MediaStreamConstraints['audio']
-  /** Video constraints to use when joining the room. Default: `true`. */
-  video?: MediaStreamConstraints['video']
-  layout?: string
-  positions?: VideoPositions
-}
-
-/**
- * @deprecated Use {@link StartScreenShareOptions} instead.
- */
-export interface CreateScreenShareObjectOptions
-  extends StartScreenShareOptions {}
-
-export type AddDeviceOptions = {
-  autoJoin?: boolean
-  audio?: MediaStreamConstraints['audio']
-  video?: MediaStreamConstraints['video']
-}
-
-export type AddCameraOptions = MediaTrackConstraints & {
-  autoJoin?: boolean
-}
-export type AddMicrophoneOptions = MediaTrackConstraints & {
-  autoJoin?: boolean
-}
-
-export interface BaseRoomInterface {
-  join(): Promise<unknown>
-  leave(): Promise<unknown>
-}
-
-interface RoomMemberSelfMethodsInterface {
-  /**
-   * Puts the microphone on mute. The other participants will not hear audio
-   * from the muted device anymore.
-   *
-   * @permissions
-   *  - `room.self.audio_mute`
-   *
-   * You need to specify the permissions when [creating the Video Room
-   * Token](https://developer.signalwire.com/apis/reference/create_room_token)
-   * on the server side.
-   *
-   * @example Muting the microphone:
-   * ```typescript
-   * await roomdevice.audioMute()
-   * ```
-   */
-  audioMute(): Rooms.AudioMuteMember
-
-  /**
-   * Unmutes the microphone if it had been previously muted.
-   *
-   * @permissions
-   *  - `room.self.audio_unmute`
-   *
-   * You need to specify the permissions when [creating the Video Room
-   * Token](https://developer.signalwire.com/apis/reference/create_room_token)
-   * on the server side.
-   *
-   * @example Unmuting the microphone:
-   * ```typescript
-   * await roomdevice.audioUnmute()
-   * ```
-   */
-  audioUnmute(): Rooms.AudioUnmuteMember
-
-  /**
-   * Puts the video on mute. Participants will see a mute image instead of the
-   * video stream.
-   *
-   * @permissions
-   *  - `room.self.video_mute`
-   *
-   * You need to specify the permissions when [creating the Video Room
-   * Token](https://developer.signalwire.com/apis/reference/create_room_token)
-   * on the server side.
-   *
-   * @example Muting the camera:
-   * ```typescript
-   * await roomdevice.videoMute()
-   * ```
-   */
-  videoMute(): Rooms.VideoMuteMember
-
-  /**
-   * Unmutes the video if it had been previously muted. Participants will start
-   * seeing the video stream again.
-   *
-   * @permissions
-   *  - `room.self.video_unmute`
-   *
-   * You need to specify the permissions when [creating the Video Room
-   * Token](https://developer.signalwire.com/apis/reference/create_room_token)
-   * on the server side.
-   *
-   * @example Unmuting the camera:
-   * ```typescript
-   * await roomdevice.videoUnmute()
-   * ```
-   */
-  videoUnmute(): Rooms.VideoUnmuteMember
-
-  /**
-   * @deprecated Use {@link setInputVolume} instead.
-   */
-  setMicrophoneVolume(params: { volume: number }): Rooms.SetInputVolumeMember
-
-  /**
-   * Sets the input volume level (e.g. for the microphone).
-   * @param params
-   * @param params.volume desired volume. Values range from -50 to 50, with a
-   * default of 0.
-   *
-   * @permissions
-   *  - `room.self.set_input_volume`
-   *
-   * You need to specify the permissions when [creating the Video Room
-   * Token](https://developer.signalwire.com/apis/reference/create_room_token)
-   * on the server side.
-   *
-   * @example
-   * ```typescript
-   * await roomdevice.setMicrophoneVolume({volume: -10})
-   * ```
-   */
-  setInputVolume(params: { volume: number }): Rooms.SetInputVolumeMember
-
-  /**
-   * Sets the input level at which the participant is identified as currently
-   * speaking.
-   * @param params
-   * @param params.value desired sensitivity. The default value is 30 and the
-   * scale goes from 0 (lowest sensitivity, essentially muted) to 100 (highest
-   * sensitivity).
-   *
-   * @permissions
-   *  - `room.self.set_input_sensitivity`
-   *
-   * You need to specify the permissions when [creating the Video Room
-   * Token](https://developer.signalwire.com/apis/reference/create_room_token)
-   * on the server side.
-   *
-   * @example
-   * ```typescript
-   * await roomdevice.setInputSensitivity({value: 80})
-   * ```
-   */
-  setInputSensitivity(params: {
-    value: number
-  }): Rooms.SetInputSensitivityMember
-}
-
-/**
- * We are using these interfaces in combination of
- * Object.defineProperties() to avoid code duplication and
- * expose a nice documentation via TypeDoc. The interface
- * forces TS checking while Object.defineProperties allow us
- * flexibility across different objects.
- */
-export interface VideoRoomSessionMethods
-  extends OnlyFunctionProperties<CoreVideoRoomSessionContract> {
-  /** @deprecated Use {@link setVideoMuted} instead */
-  hideVideoMuted(): Rooms.HideVideoMuted
-  /** @deprecated Use {@link setVideoMuted} instead */
-  showVideoMuted(): Rooms.ShowVideoMuted
-}
-
-export interface VideoRoomSessionContract {
-  deviceList: RoomSessionDevice[]
-  interactivityMode: VideoAuthorization['join_as']
-  permissions: VideoAuthorization['scopes']
-  /** The `layout.changed` event based on the current room layout */
-  currentLayoutEvent: VideoLayoutChangedEventParams
-  /** The layout returned from the `layout.changed` event based on the current room layout */
-  currentLayout: VideoLayoutChangedEventParams['layout']
-  /** The current position of the member returned from the `layout.changed` event */
-  currentPosition: VideoPosition | undefined
-  /**
-   * Joins the room session.
-   */
-  join(options?: BaseRoomSessionJoinParams): Promise<VideoRoomSessionContract>
-  /**
-   * Adds a screen sharing instance to the room. You can create multiple screen
-   * sharing instances and add all of them to the room.
-   * @param opts - {@link CreateScreenShareObjectOptions}
-   * @returns - {@link RoomSessionScreenShare}
-   *
-   * @deprecated Use {@link startScreenShare} instead.
-   */
-  createScreenShareObject(
-    opts?: CreateScreenShareObjectOptions
-  ): Promise<RoomSessionScreenShare>
-  /**
-   * Adds a camera device to the room. Using this method, a user can stream
-   * multiple video sources at the same time.
-   *
-   * @param opts - Specify the constraints for the device. In addition, you can
-   * add the `autoJoin` key to specify whether the device should immediately
-   * join the room or joining will be performed manually later. {@link AddCameraOptions}
-   * @returns - {@link RoomSessionDevice}
-   *
-   * @example Adding a specific camera:
-   * ```typescript
-   * await roomSession.addCamera({deviceId: "gOtMHwZdoA6wMlAnhbfTmeRgPAsqa7iw1OwgKYtbTLA="})
-   * ```
-   */
-  addCamera(opts: AddCameraOptions): Promise<RoomSessionDevice>
-  /**
-   * Adds a microphone device to the room. Using this method, a user can stream
-   * multiple video sources at the same time.
-   *
-   * @param opts Specify the constraints for the device. In addition, you can
-   * add the `autoJoin` key to specify whether the device should immediately
-   * join the room or joining will be performed manually later. {@link AddMicrophoneOptions}
-   * @returns - {@link RoomSessionDevice}
-   *
-   * @example Adding a specific microphone:
-   * ```typescript
-   * await roomSession.addMicrophone({deviceId: "PIn/IIDDgBUHzJkhRncv1m85hX1gC67xYIgJvvThB3Q="})
-   * ```
-   */
-  addMicrophone(opts: AddMicrophoneOptions): Promise<RoomSessionDevice>
-  /**
-   * Adds a device to the room. Using this method, a user can stream multiple
-   * sources at the same time. If you need to add a camera device or a
-   * microphone device, you can alternatively use the more specific methods
-   * {@link addCamera} and {@link addMicrophone}.
-   *
-   * @param opts Specify the constraints for the device. In addition, you can
-   * add the `autoJoin` key to specify whether the device should immediately
-   * join the room or joining will be performed manually later. {@link AddDeviceOptions}
-   * @returns - {@link RoomSessionDevice}
-   *
-   * @example Adding any of the microphone devices to the room (duplicate
-   * streams are possible):
-   * ```typescript
-   * await roomSession.addDevice({audio: true})
-   * ```
-   */
-  addDevice(opts: AddDeviceOptions): Promise<RoomSessionDevice>
-}
-
-export interface RoomSessionDeviceMethods
-  extends RoomMemberSelfMethodsInterface {}
-
-export interface RoomScreenShareMethods
-  extends RoomMemberSelfMethodsInterface {}
-
-export interface BaseRoomSessionJoinParams {
-  audio?: MediaStreamConstraints['audio']
-  video?: MediaStreamConstraints['video']
-  receiveAudio?: boolean
-  receiveVideo?: boolean
-  sendAudio?: boolean
-  sendVideo?: boolean
-}
-
-export type PagingCursor =
-  | {
-      before: string
-      after?: never
-    }
-  | {
-      before?: never
-      after: string
-    }
-
-export type AudioElement = HTMLAudioElement & {
-  sinkId?: string
-  setSinkId?: (id: string) => Promise<void>
-}

package/src/utils/makeQueryParamsUrl.ts

@@ -1,14 +0,0 @@
-/**
- * Constructs a URL with query parameters.
- *
- * @param path The base path of the URL.
- * @param queryParams An instance of URLSearchParams containing all query parameters.
- * @returns The constructed URL with query parameters.
- */
-export function makeQueryParamsUrls(
-  path: string,
-  queryParams: URLSearchParams
-): string {
-  const queryString = queryParams.toString()
-  return queryString ? `${path}?${queryString}` : path
-}

package/src/utils/paginatedResult.ts

@@ -1,35 +0,0 @@
-import { PaginatedResponse } from '../fabric/interfaces'
-import { CreateHttpClient } from '../fabric/createHttpClient'
-
-export function buildPaginatedResult<T>(
-  body: PaginatedResponse<T>,
-  client: CreateHttpClient
-) {
-  const anotherPage = async (url?: string) => {
-    if (!url) return Promise.resolve(undefined)
-    const { body } = await client<PaginatedResponse<T>>(url)
-    return buildPaginatedResult<T>(body, client)
-  }
-
-  return {
-    data: body.data,
-    self: async () => {
-      const { self } = body.links
-      return anotherPage(self)
-    },
-    nextPage: async () => {
-      const { next } = body.links
-      return anotherPage(next)
-    },
-    prevPage: async () => {
-      const { prev } = body.links
-      return anotherPage(prev)
-    },
-    firstPage: async () => {
-      const { first } = body.links
-      return anotherPage(first)
-    },
-    hasNext: Boolean(body.links.next),
-    hasPrev: Boolean(body.links.prev),
-  }
-}

package/src/utils/roomSession.test.ts

@@ -1,140 +0,0 @@
-import type { VideoAuthorization } from '@signalwire/core'
-import { BaseRoomSessionJoinParams } from './interfaces'
-import { getJoinMediaParams } from './roomSession'
-
-describe('getJoinMediaParams', () => {
-  const authorization: VideoAuthorization = {
-    type: 'video',
-    project: 'project_id',
-    scopes: ['video'],
-    scope_id: 'scope_id',
-    resource: 'resource',
-    join_as: 'member',
-    user_name: 'memberName',
-    meta: {},
-    audio_allowed: 'both',
-    video_allowed: 'both',
-    room: {
-      name: 'jest',
-      display_name: 'Jest',
-      scopes: [],
-      meta: {},
-    },
-    signature: 'signature',
-    project_id: '',
-  }
-  const authStateMap = new Map<string, VideoAuthorization>()
-  authStateMap.set('member-all', authorization)
-  authStateMap.set('member-audio-only', {
-    ...authorization,
-    video_allowed: 'none',
-  })
-  authStateMap.set('member-video-only', {
-    ...authorization,
-    audio_allowed: 'none',
-  })
-  authStateMap.set('audience-all', {
-    ...authorization,
-    join_as: 'audience',
-  })
-  authStateMap.set('audience-audio-only', {
-    ...authorization,
-    join_as: 'audience',
-    video_allowed: 'none',
-  })
-  authStateMap.set('audience-video-only', {
-    ...authorization,
-    join_as: 'audience',
-    audio_allowed: 'none',
-  })
-
-  /**
-   * Build all the combinations of arguments that `getJoinMediaParams()`
-   * could receive.
-   */
-  const keys: (keyof BaseRoomSessionJoinParams)[] = [
-    'sendAudio',
-    'receiveAudio',
-    'sendVideo',
-    'receiveVideo',
-    'audio',
-    'video',
-  ]
-  const cases: BaseRoomSessionJoinParams[] = []
-  const booleans = [true, false]
-  keys.forEach((key, index) => {
-    booleans.forEach((bool) => {
-      const tmp: BaseRoomSessionJoinParams = {}
-      for (let i = index; i < keys.length; i++) {
-        tmp[keys[i]] = bool
-      }
-
-      tmp[key] = bool
-      cases.push(tmp)
-
-      if (Object.keys(tmp).length > 1) {
-        cases.push({ ...tmp, [key]: !bool })
-        cases.push({ [key]: bool })
-      }
-    })
-  })
-
-  /**
-   * Build describe/test blocks dynamically for
-   * JoinAs types: member / audience
-   * Media Allowed: 'all', 'audio-only', 'video-only'
-   *
-   * For each pair, do a test with all the possible
-   * combinations built above to make sure the correct
-   * values are returned by `getJoinMediaParams()`
-   *
-   * The logic used in here is different from the implementation
-   * of `getJoinMediaParams` to prove the correct values.
-   */
-  const joinAs = ['member', 'audience']
-  const mediaDirectionAllowed = ['all', 'audio-only', 'video-only']
-  joinAs.forEach((joinType) => {
-    describe(`as ${joinType}`, () => {
-      mediaDirectionAllowed.forEach((direction) => {
-        describe(`with media_allowed: '${direction}'`, () => {
-          cases.forEach((params) => {
-            const {
-              audio = true, // true if undefined
-              video = true, // true if undefined
-              sendAudio,
-              receiveAudio,
-              sendVideo,
-              receiveVideo,
-            } = params
-
-            // prettier-ignore
-            const reqToSendAudio = typeof sendAudio !== 'undefined' ? sendAudio : Boolean(audio)
-            // prettier-ignore
-            const reqToSendVideo = typeof sendVideo !== 'undefined' ? sendVideo : Boolean(video)
-            // prettier-ignore
-            const reqToRecvAudio = typeof receiveAudio !== 'undefined' ? receiveAudio : Boolean(audio)
-            // prettier-ignore
-            const reqToRecvVideo = typeof receiveVideo !== 'undefined' ? receiveVideo : Boolean(video)
-
-            it(`should handle params: ${JSON.stringify(params)}`, () => {
-              const authorization = authStateMap.get(`${joinType}-${direction}`)
-              if (!authorization) {
-                throw 'Invalid Authorization'
-              }
-              const result = getJoinMediaParams({ ...params, authorization })
-
-              expect(result).toStrictEqual({
-                // prettier-ignore
-                mustSendAudio: joinType === 'member' && direction !== 'video-only' && reqToSendAudio,
-                // prettier-ignore
-                mustSendVideo: joinType === 'member' && direction !== 'audio-only' && reqToSendVideo,
-                mustRecvAudio: direction !== 'video-only' && reqToRecvAudio,
-                mustRecvVideo: direction !== 'audio-only' && reqToRecvVideo,
-              })
-            })
-          })
-        })
-      })
-    })
-  })
-})