@signalwire/js 3.23.3 → 3.23.4

package/src/cantina/VideoManager.ts

@@ -1,19 +1,15 @@
 import {
   BaseComponentOptions,
-  BaseConsumer,
   VideoManagerRoomEventNames,
-  InternalVideoManagerRoomEventNames,
   connect,
   ConsumerContract,
-  EventTransform,
-  toExternalJSON,
   VideoManagerRoomEntity,
-  VideoManagerRoomsSubscribedEventParams,
+  validateEventsToSubscribe,
+  EventEmitter,
+  BaseConsumer,
 } from '@signalwire/core'
 import { videoManagerWorker } from './workers'
 
-type EmitterTransformsEvents = InternalVideoManagerRoomEventNames
-
 /** @internal */
 export type VideoManagerEvents = Record<
   VideoManagerRoomEventNames,
@@ -25,9 +21,7 @@ export interface VideoManager extends ConsumerContract<VideoManagerEvents> {}
 
 /** @internal */
 export class VideoManagerAPI extends BaseConsumer<VideoManagerEvents> {
-  protected _eventsPrefix = 'video-manager' as const
-
-  constructor(options: BaseComponentOptions<VideoManagerEvents>) {
+  constructor(options: BaseComponentOptions) {
     super(options)
 
     this.runWorker('videoManagerWorker', {
@@ -36,50 +30,15 @@ export class VideoManagerAPI extends BaseConsumer<VideoManagerEvents> {
   }
 
   /** @internal */
-  getEmitterTransforms() {
-    return new Map<
-      EmitterTransformsEvents | EmitterTransformsEvents[],
-      EventTransform
-    >([
-      [
-        ['video-manager.rooms.subscribed'],
-        {
-          type: 'roomSession',
-          // For now we expose the transformed payload and not a RoomSession
-          instanceFactory: ({
-            rooms,
-          }: VideoManagerRoomsSubscribedEventParams) => ({
-            rooms: rooms.map((row) => toExternalJSON(row)),
-          }),
-          payloadTransform: ({
-            rooms,
-          }: VideoManagerRoomsSubscribedEventParams) => ({
-            rooms: rooms.map((row) => toExternalJSON(row)),
-          }),
-        },
-      ],
-      [
-        [
-          'video-manager.room.started',
-          'video-manager.room.added',
-          'video-manager.room.updated',
-          'video-manager.room.ended',
-          'video-manager.room.deleted',
-        ],
-        {
-          type: 'roomSession',
-          // For now we expose the transformed payload and not a RoomSession
-          instanceFactory: (payload) => toExternalJSON(payload),
-          payloadTransform: (payload) => toExternalJSON(payload),
-        },
-      ],
-    ])
+  protected override getSubscriptions() {
+    const eventNamesWithPrefix = this.eventNames().map(
+      (event) => `video-manager.${event}`
+    ) as EventEmitter.EventNames<VideoManagerEvents>[]
+    return validateEventsToSubscribe(eventNamesWithPrefix)
   }
 }
 
-export const createVideoManagerObject = (
-  params: BaseComponentOptions<VideoManagerEvents>
-) => {
+export const createVideoManagerObject = (params: BaseComponentOptions) => {
   const manager = connect<VideoManagerEvents, VideoManagerAPI, VideoManager>({
     store: params.store,
     Component: VideoManagerAPI,

package/src/cantina/workers/index.ts

@@ -0,0 +1 @@
+export * from './videoManagerWorker'

package/src/cantina/workers/videoManagerRoomWorker.ts

@@ -0,0 +1,28 @@
+import {
+  getLogger,
+  SagaIterator,
+  MapToPubSubShape,
+  VideoManagerRoomEvent,
+  toExternalJSON,
+  VideoManagerRoomEventNames,
+  stripNamespacePrefix,
+} from '@signalwire/core'
+import { VideoManagerWorkerParams } from './videoManagerWorker'
+
+export const videoManagerRoomWorker = function* (
+  options: VideoManagerWorkerParams<MapToPubSubShape<VideoManagerRoomEvent>>
+): SagaIterator {
+  getLogger().trace('videoManagerRoomWorker started')
+  const {
+    instance: client,
+    action: { type, payload },
+  } = options
+
+  // For now we expose the transformed payload and not a RoomSession
+  client.emit(
+    stripNamespacePrefix(type) as VideoManagerRoomEventNames,
+    toExternalJSON(payload)
+  )
+
+  getLogger().trace('videoManagerRoomWorker ended')
+}

package/src/cantina/workers/videoManagerRoomsWorker.ts

@@ -0,0 +1,33 @@
+import {
+  getLogger,
+  SagaIterator,
+  MapToPubSubShape,
+  VideoManagerRoomsSubscribedEvent,
+  toExternalJSON,
+  VideoManagerRoomEventNames,
+  stripNamespacePrefix,
+} from '@signalwire/core'
+import { VideoManagerWorkerParams } from './videoManagerWorker'
+
+export const videoManagerRoomsWorker = function* (
+  options: VideoManagerWorkerParams<
+    MapToPubSubShape<VideoManagerRoomsSubscribedEvent>
+  >
+): SagaIterator {
+  getLogger().trace('videoManagerRoomsWorker started')
+  const {
+    instance: client,
+    action: { type, payload },
+  } = options
+
+  // For now we expose the transformed payload and not a RoomSession
+  const modPayload = {
+    rooms: payload.rooms.map((row) => toExternalJSON(row)),
+  }
+  client.emit(
+    stripNamespacePrefix(type) as VideoManagerRoomEventNames,
+    modPayload
+  )
+
+  getLogger().trace('videoManagerRoomsWorker ended')
+}

package/src/cantina/workers/videoManagerWorker.ts

@@ -0,0 +1,64 @@
+import { getLogger, sagaEffects } from '@signalwire/core'
+import type {
+  SagaIterator,
+  MapToPubSubShape,
+  VideoManagerEvent,
+  SDKWorker,
+  SDKActions,
+  SDKWorkerParams,
+} from '@signalwire/core'
+import type { VideoManager } from '../VideoManager'
+import { videoManagerRoomsWorker } from './videoManagerRoomsWorker'
+import { videoManagerRoomWorker } from './videoManagerRoomWorker'
+
+export type VideoManagerWorkerParams<T> = SDKWorkerParams<VideoManager> & {
+  action: T
+}
+
+export const videoManagerWorker: SDKWorker<VideoManager> = function* (
+  options
+): SagaIterator {
+  getLogger().trace('videoManagerWorker started')
+  const {
+    channels: { swEventChannel },
+  } = options
+
+  function* worker(action: MapToPubSubShape<VideoManagerEvent>) {
+    const { type } = action
+
+    switch (type) {
+      case 'video-manager.rooms.subscribed':
+        yield sagaEffects.fork(videoManagerRoomsWorker, {
+          action,
+          ...options,
+        })
+        break
+      case 'video-manager.room.added':
+      case 'video-manager.room.deleted':
+      case 'video-manager.room.ended':
+      case 'video-manager.room.started':
+      case 'video-manager.room.updated':
+        yield sagaEffects.fork(videoManagerRoomWorker, {
+          action,
+          ...options,
+        })
+        break
+      default:
+        getLogger().warn(`Unknown video-manager event: "${type}"`)
+        break
+    }
+  }
+
+  while (true) {
+    const action: MapToPubSubShape<VideoManagerEvent> = yield sagaEffects.take(
+      swEventChannel,
+      (action: SDKActions) => {
+        return action.type.startsWith('video-manager.')
+      }
+    )
+
+    yield sagaEffects.fork(worker, action)
+  }
+
+  getLogger().trace('videoManagerWorker ended')
+}

package/src/createRoomObject.ts

@@ -104,7 +104,6 @@ export const createRoomObject = (
 
     // WebRTC connection left the room.
     roomObject.once('destroy', () => {
-      // @ts-expect-error
       roomObject.emit('room.left')
       client.disconnect()
     })

package/src/fabric/WSClient.ts

@@ -104,7 +104,7 @@ export class WSClient {
           return new Promise(async (resolve, reject) => {
             try {
               // @ts-expect-error
-              call.emitter.once('verto.display', () => resolve(call))
+              call.once('verto.display', () => resolve(call))
               call.once('room.subscribed', () => resolve(call))
 
               await call.join()
@@ -241,7 +241,6 @@ export class WSClient {
 
   updateToken(token: string): Promise<void> {
     return new Promise((resolve, reject) => {
-      // @ts-expect-error
       this.wsClient.once('session.auth_error', (error) => {
         reject(error)
       })

package/src/features/mediaElements/mediaElementsSagas.ts

@@ -3,6 +3,7 @@ import {
   CustomSagaParams,
   actions,
   sagaEffects,
+  LOCAL_EVENT_PREFIX,
 } from '@signalwire/core'
 import type { SagaIterator, Task } from '@signalwire/core'
 import { setMediaElementSinkId } from '@signalwire/webrtc'
@@ -124,7 +125,7 @@ export const makeVideoElementSaga = ({
       }
 
       // @ts-expect-error
-      room.on('_internal.mirror.video', (value: boolean) => {
+      room.on(`${LOCAL_EVENT_PREFIX}.mirror.video`, (value: boolean) => {
         localOverlay.setLocalOverlayMirror(value)
       })
 
@@ -288,8 +289,11 @@ function* audioElementActionsWatcher({
             action.payload
           )
 
-          // @ts-expect-error
-          room.emit('_internal.speaker.updated', action.payload)
+          room.emit(
+            // @ts-expect-error
+            `${LOCAL_EVENT_PREFIX}.speaker.updated`,
+            action.payload
+          )
 
           room.settleCustomSagaTrigger({
             dispatchId: action.dispatchId,

package/src/utils/interfaces.ts

@@ -36,6 +36,7 @@ import type {
   DeviceUpdatedEventParams,
   VideoRoomDeviceDisconnectedEventNames,
   DeviceDisconnectedEventParams,
+  VideoRoomDeviceEventNames,
 } from '@signalwire/core'
 import { INTERNAL_MEMBER_UPDATABLE_PROPS } from '@signalwire/core'
 import type { MediaEvent } from '@signalwire/webrtc'
@@ -92,9 +93,10 @@ export type RoomEventNames =
   | RTCTrackEventName
 
 export type RoomSessionObjectEventsHandlerMap = Record<
-  VideoLayoutEventNames,
-  (params: { layout: VideoLayout }) => void
+  VideoRoomDeviceEventNames,
+  (params: DeviceUpdatedEventParams) => void
 > &
+  Record<VideoLayoutEventNames, (params: { layout: VideoLayout }) => void> &
   Record<
     Exclude<
       VideoMemberEventNames,

package/src/utils/videoElement.ts

@@ -122,6 +122,7 @@ const makeLayoutChangedHandler =
         localVideo.style.width = '100%'
         localVideo.style.height = '100%'
         localVideo.style.pointerEvents = 'none'
+        localVideo.style.objectFit = 'cover'
 
         myLayer.appendChild(localVideo)
 

package/src/video/childMemberJoinedWorker.test.ts

@@ -1,18 +1,20 @@
-import { testUtils, componentActions, sagaHelpers } from '@signalwire/core'
+import { testUtils, componentActions } from '@signalwire/core'
 import { expectSaga } from 'redux-saga-test-plan'
 import { childMemberJoinedWorker } from './childMemberJoinedWorker'
 
-const { createPubSubChannel, createSwEventChannel } = testUtils
+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 session = {} as any
-    const pubSubChannel = createPubSubChannel()
     const swEventChannel = createSwEventChannel()
-    const sessionChannel = sagaHelpers.eventChannel(() => () => {})
+    const sessionChannel = createSessionChannel()
+    const session = {
+      connect: jest.fn(),
+    } as any
+    const getSession = jest.fn().mockImplementation(() => session)
     const dispatchedActions: unknown[] = []
     const defaultState = {
       components: {
@@ -32,21 +34,19 @@ describe('childMemberJoinedWorker', () => {
     }
 
     return expectSaga(childMemberJoinedWorker, {
-      // @ts-expect-error
-      session,
       channels: {
-        pubSubChannel,
         swEventChannel,
+        sessionChannel,
       },
-      sessionChannel,
       instance: {
         callId: 'callId',
-        _attachListeners: jest.fn(),
-        applyEmitterTransforms: jest.fn(),
       } as any,
       initialState: {
         parentId,
       },
+      instanceMap: { get: jest.fn(), set: jest.fn(), remove: jest.fn() },
+      getSession,
+      runSaga: jest.fn(),
     })
       .withState(defaultState)
       .provide([
@@ -68,7 +68,6 @@ describe('childMemberJoinedWorker', () => {
               }
             } else if (runSaga === false) {
               sessionChannel.close()
-              pubSubChannel.close()
             }
             return next()
           },

package/src/video/childMemberJoinedWorker.ts

@@ -57,15 +57,6 @@ export const childMemberJoinedWorker: SDKWorker<
       return 'memberId' in row && row.memberId === member.parent_id
     })
     if (parent) {
-      /**
-       * For screenShare/additionalDevice we're using the `memberId` to
-       * namespace the object.
-       **/
-      // @ts-expect-error
-      instance._attachListeners(member.id)
-      // @ts-expect-error
-      instance.applyEmitterTransforms()
-
       yield sagaEffects.put(
         componentActions.upsert({
           id: instance.callId,

package/src/video/memberListUpdatedWorker.ts

@@ -5,7 +5,7 @@ import {
   toSyntheticEvent,
   validateEventsToSubscribe,
   toInternalEventName,
-  PubSubChannel,
+  SwEventChannel,
   InternalVideoMemberEntity,
   InternalVideoMemberUpdatedEvent,
   VideoMemberJoinedEvent,
@@ -19,7 +19,7 @@ import type { VideoMemberListUpdatedParams } from '../utils/interfaces'
 
 const noop = () => {}
 
-const EXTERNAL_MEMBER_LIST_UPDATED_EVENT = 'video.memberList.updated'
+const EXTERNAL_MEMBER_LIST_UPDATED_EVENT = 'memberList.updated'
 
 const INTERNAL_MEMBER_LIST_UPDATED_EVENT = toInternalEventName({
   event: EXTERNAL_MEMBER_LIST_UPDATED_EVENT,
@@ -57,7 +57,9 @@ const isMemberListEvent = (
   return MEMBER_LIST_EVENTS.includes(event)
 }
 
-const getMemberListEventsToSubscribe = (subscriptions: MemberListUpdatedTargetActions['type'][]) => {
+const getMemberListEventsToSubscribe = (
+  subscriptions: MemberListUpdatedTargetActions['type'][]
+) => {
   return validateEventsToSubscribe(MEMBER_LIST_EVENTS).filter((event) => {
     return !subscriptions.includes(event)
   })
@@ -65,7 +67,7 @@ const getMemberListEventsToSubscribe = (subscriptions: MemberListUpdatedTargetAc
 
 const shouldHandleMemberList = (subscriptions: string[]) => {
   return subscriptions.some((event) =>
-    event.includes(INTERNAL_MEMBER_LIST_UPDATED_EVENT)
+    event.includes(EXTERNAL_MEMBER_LIST_UPDATED_EVENT)
   )
 }
 
@@ -128,7 +130,6 @@ const initMemberListSubscriptions = (
    * synthetic events and external events.
    */
   const eventBridgeHandler = ({ members }: VideoMemberListUpdatedParams) => {
-    // @ts-expect-error
     room.emit(EXTERNAL_MEMBER_LIST_UPDATED_EVENT, { members })
   }
 
@@ -150,9 +151,11 @@ const initMemberListSubscriptions = (
 }
 
 function* membersListUpdatedWatcher({
-  pubSubChannel,
+  swEventChannel,
+  instance,
 }: {
-  pubSubChannel: PubSubChannel
+  swEventChannel: SwEventChannel
+  instance: any
 }): SagaIterator {
   const memberList: MemberList = new Map()
 
@@ -174,16 +177,12 @@ function* membersListUpdatedWatcher({
       members,
     }
 
-    // TODO: add typings
-    yield sagaEffects.put(pubSubChannel, {
-      type: SYNTHETIC_MEMBER_LIST_UPDATED_EVENT as any,
-      payload: memberListPayload as any,
-    })
+    instance.emit(SYNTHETIC_MEMBER_LIST_UPDATED_EVENT, memberListPayload)
   }
 
   while (true) {
     const pubSubAction: MemberListUpdatedTargetActions = yield sagaEffects.take(
-      pubSubChannel,
+      swEventChannel,
       ({ type }: any) => {
         return isMemberListEvent(type)
       }
@@ -195,7 +194,7 @@ function* membersListUpdatedWatcher({
 
 export const memberListUpdatedWorker: SDKWorker<RoomSession> =
   function* membersChangedWorker({
-    channels: { pubSubChannel },
+    channels: { swEventChannel },
     instance,
   }): SagaIterator {
     // @ts-expect-error
@@ -208,7 +207,8 @@ export const memberListUpdatedWorker: SDKWorker<RoomSession> =
     const { cleanup } = initMemberListSubscriptions(instance, subscriptions)
 
     yield sagaEffects.fork(membersListUpdatedWatcher, {
-      pubSubChannel,
+      swEventChannel,
+      instance,
     })
 
     instance.once('destroy', () => {

package/src/video/videoPlaybackWorker.ts

@@ -0,0 +1,54 @@
+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/videoRecordWorker.ts

@@ -0,0 +1,54 @@
+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/videoStreamWorker.ts

@@ -0,0 +1,48 @@
+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')
+}