@signalwire/js 3.29.2 → 4.0.0-beta.0

package/src/fabric/workers/callSegmentWorker.ts

@@ -1,154 +0,0 @@
-import {
-  FabricAction,
-  CallJoinedEvent,
-  SDKActions,
-  SagaIterator,
-  getLogger,
-  sagaEffects,
-} from '@signalwire/core'
-import { callLeftWorker } from './callLeftWorker'
-import { callJoinWorker } from './callJoinWorker'
-import { FabricWorkerParams } from './fabricWorker'
-import {
-  mapFabricLayoutActionToVideoLayoutAction,
-  mapFabricMemberActionToVideoMemberJoinAndLeftAction,
-  mapFabricMemberActionToVideoMemberUpdatedAction,
-} from '../utils/eventMappers'
-import { fabricMemberWorker } from './fabricMemberWorker'
-
-export const callSegmentWorker = function* (
-  options: FabricWorkerParams<CallJoinedEvent>
-): SagaIterator {
-  const {
-    action,
-    channels: { swEventChannel },
-    instance: cfRoomSession,
-  } = options
-  const segmentCallId = action.payload.call_id
-  const segmentRooSessionId = action.payload.room_session_id
-
-  getLogger().debug(
-    `callSegmentWorker started for: callId ${segmentCallId}, roomSessionId ${segmentRooSessionId}`
-  )
-
-  // Handles the `call.joined` event before the worker loop
-  yield sagaEffects.fork(callJoinWorker, {
-    ...options,
-    action,
-  })
-
-  function* worker(action: FabricAction) {
-    const { type, payload } = action
-
-    switch (type) {
-      case 'call.joined':
-        /** NOOP since this event is handled by the {@link fabricWorker} */
-        break
-      case 'call.left':
-        // Wait for the `callLeftWorker` to finish and then stop this particular segment worker
-        yield sagaEffects.call(callLeftWorker, {
-          ...options,
-          action,
-        })
-        return true
-      case 'call.updated':
-        cfRoomSession.emit(type, payload)
-        cfRoomSession.emit('room.updated', payload)
-        break
-      case 'call.play':
-        cfRoomSession.emit(type, payload)
-        break
-      case 'call.connect':
-        cfRoomSession.emit(type, payload)
-        break
-      case 'call.room':
-        cfRoomSession.emit(type, payload)
-        break
-
-      /**
-       * The Core module includes a generic worker, {@link memberPositionWorker},
-       * which listens for member & layout events to add a "current_position" parameter
-       * and handle member "updated" parameter.
-       * This worker in CF SDK is initialized by the {@link callJoinWorker} worker.
-       *
-       * To ensure compatibility, we map these events to Video SDK events and
-       * re-publish them on the channel so that they can be processed by the
-       * generic worker. Note that the generic worker only dispatches "member.updated"
-       * and "member.updated.*" events.
-       *
-       * Additionally, the "member.joined" event is monitored by another worker,
-       * {@link childMemberJoinedWorker}, specifically for the screen share API.
-       */
-      case 'member.joined':
-      case 'member.left': {
-        yield sagaEffects.fork(fabricMemberWorker, {
-          ...options,
-          action,
-        })
-        const videoAction =
-          mapFabricMemberActionToVideoMemberJoinAndLeftAction(action)
-        yield sagaEffects.put(swEventChannel, videoAction)
-        break
-      }
-      case 'member.updated': {
-        const videoAction =
-          mapFabricMemberActionToVideoMemberUpdatedAction(action)
-        yield sagaEffects.put(swEventChannel, videoAction)
-        break
-      }
-      case 'layout.changed': {
-        // We need to update the layout event which is needed for rootElement.
-        cfRoomSession.currentLayoutEvent = action.payload
-        cfRoomSession.emit(type, payload)
-        const videoAction = mapFabricLayoutActionToVideoLayoutAction(action)
-        yield sagaEffects.put(swEventChannel, videoAction)
-        break
-      }
-      case 'member.talking': {
-        yield sagaEffects.fork(fabricMemberWorker, {
-          ...options,
-          action,
-        })
-        break
-      }
-      default: {
-        getLogger().warn('Got an unknown fabric event', action)
-      }
-    }
-
-    return false
-  }
-
-  const isSegmentEvent = (action: SDKActions) => {
-    const { type, payload } = action as FabricAction
-    const shouldWatch =
-      type.startsWith('call.') ||
-      type.startsWith('member.') ||
-      type.startsWith('layout.')
-    const hasSegmentCallId =
-      'call_id' in payload && segmentCallId === payload.call_id
-    const hasSegmentRoomSessionId =
-      segmentRooSessionId === payload.room_session_id
-
-    if (shouldWatch && (hasSegmentCallId || hasSegmentRoomSessionId)) {
-      return true
-    }
-
-    return false
-  }
-
-  while (true) {
-    const action: FabricAction = yield sagaEffects.take(
-      swEventChannel,
-      isSegmentEvent
-    )
-    const task = yield sagaEffects.fork(worker, action)
-
-    /**
-     * Wait for `worker` to finish and get its return value
-     * Stop the `callSegmentWorker' if the returned value is true
-     */
-    const shouldStop = yield sagaEffects.join(task)
-    if (shouldStop) return
-  }
-}

package/src/fabric/workers/fabricMemberWorker.ts

@@ -1,62 +0,0 @@
-import {
-  FabricMemberEvent,
-  FabricMemberUpdatedEventParams,
-  MemberUpdatedEventNames,
-  SagaIterator,
-  fromSnakeToCamelCase,
-  getLogger,
-} from '@signalwire/core'
-import { FabricWorkerParams } from './fabricWorker'
-import {
-  createFabricRoomSessionMemberObject,
-  FabricRoomSessionMember,
-} from '../FabricRoomSessionMember'
-
-export const fabricMemberWorker = function* (
-  options: FabricWorkerParams<FabricMemberEvent>
-): SagaIterator {
-  getLogger().trace('fabricMemberWorker started')
-  const {
-    instance: roomSession,
-    action: { type, payload },
-    instanceMap: { get, set, remove },
-  } = options
-
-  const memberId = payload.member.member_id
-  let memberInstance = get<FabricRoomSessionMember>(memberId)
-  if (!memberInstance && type !== 'member.talking') {
-    memberInstance = createFabricRoomSessionMemberObject({
-      store: roomSession.store,
-      payload: payload,
-    })
-  }
-  if (memberInstance) {
-    memberInstance.setPayload(payload)
-  }
-  set<FabricRoomSessionMember>(memberId, memberInstance)
-
-  if (type.startsWith('member.updated.')) {
-    const clientType = fromSnakeToCamelCase(type) as MemberUpdatedEventNames
-    roomSession.emit(clientType, payload as FabricMemberUpdatedEventParams)
-  }
-
-  switch (type) {
-    case 'member.joined':
-      roomSession.emit(type, payload)
-      break
-    case 'member.updated':
-      roomSession.emit(type, payload)
-      break
-    case 'member.left':
-      roomSession.emit(type, payload)
-      remove<FabricRoomSessionMember>(memberId)
-      break
-    case 'member.talking':
-      roomSession.emit(type, payload)
-      break
-    default:
-      break
-  }
-
-  getLogger().trace('fabricMemberWorker ended')
-}

package/src/fabric/workers/fabricWorker.ts

@@ -1,100 +0,0 @@
-import {
-  SDKWorker,
-  SagaIterator,
-  getLogger,
-  sagaEffects,
-  SDKWorkerParams,
-  SDKActions,
-  FabricAction,
-  MapToPubSubShape,
-} from '@signalwire/core'
-import { FabricRoomSessionConnection } from '../FabricRoomSession'
-import { createFabricRoomSessionMemberObject } from '../FabricRoomSessionMember'
-import { callSegmentWorker } from './callSegmentWorker'
-
-export type FabricWorkerParams<T> =
-  SDKWorkerParams<FabricRoomSessionConnection> & {
-    action: MapToPubSubShape<T>
-  }
-
-export const fabricWorker: SDKWorker<FabricRoomSessionConnection> = function* (
-  options
-): SagaIterator {
-  getLogger().trace('fabricWorker started')
-  const {
-    channels: { swEventChannel },
-    instance: cfRoomSession,
-  } = options
-
-  function* worker(action: FabricAction) {
-    const { type, payload } = action
-
-    switch (type) {
-      case 'call.joined': {
-        // since we depend on `cfRoomSession.selfMember` on the take logic
-        // we need to make sure we update the `cfRoomSession.selfMember`
-        // in this worker or have a race condition.
-        if (!cfRoomSession.selfMember) {
-          const memberInstance = createFabricRoomSessionMemberObject({
-            store: cfRoomSession.store,
-            payload: {
-              member: action.payload.room_session.members.find(
-                (m) => m.member_id === action.payload.member_id
-              )!,
-              room_id: action.payload.room_id,
-              room_session_id: action.payload.room_session_id,
-            },
-          })
-          cfRoomSession.selfMember = memberInstance
-        }
-
-        // Segment worker for each call_id
-        yield sagaEffects.fork(callSegmentWorker, {
-          ...options,
-          instance: cfRoomSession,
-          action,
-        })
-        break
-      }
-      case 'call.state':
-        cfRoomSession.emit(type, payload)
-        break
-    }
-  }
-
-  let firstCallJoinedReceived = false
-  const isFirstCallJoinedorCallStateEvent = (action: SDKActions) => {
-    if (action.type === 'call.state') {
-      return true
-    }
-
-    if (action.type !== 'call.joined') {
-      return false
-    }
-
-    // If this is the first call.joined event, verify the call origin ID
-    if (!firstCallJoinedReceived) {
-      const callId = action.payload.call_id
-      const originCallId = action.payload.origin_call_id
-      if (callId === originCallId) {
-        firstCallJoinedReceived = true
-        return true
-      }
-      return false // Discard all the call.joined event until the first call.joined is received
-    }
-
-    // If first call.joined event already received, only check the action type
-    return true
-  }
-
-  while (true) {
-    const action: FabricAction = yield sagaEffects.take(
-      swEventChannel,
-      isFirstCallJoinedorCallStateEvent
-    )
-
-    yield sagaEffects.fork(worker, action)
-  }
-
-  getLogger().trace('fabricWorker ended')
-}

package/src/fabric/workers/index.ts

@@ -1,2 +0,0 @@
-export * from './wsClientWorker'
-export * from './fabricWorker'

package/src/fabric/workers/wsClientWorker.ts

@@ -1,60 +0,0 @@
-import {
-  getLogger,
-  sagaEffects,
-  SagaIterator,
-  SDKWorker,
-  SDKActions,
-  MapToPubSubShape,
-  WebRTCMessageParams,
-} from '@signalwire/core'
-import { WSClient } from '../WSClient'
-
-export const wsClientWorker: SDKWorker<WSClient> = function* (
-  options
-): SagaIterator {
-  getLogger().debug('wsClientWorker started')
-  const { channels, initialState, instance: client } = options
-  const { swEventChannel } = channels
-  const { handleIncomingInvite } = initialState
-
-  function* fireHoseWorker(action: SDKActions) {
-    // @ts-expect-error Emit all events - This is for internal usage
-    client.emit(action.type, action.payload)
-  }
-
-  function* vertoInviteWorker(action: MapToPubSubShape<WebRTCMessageParams>) {
-    // Invoke WSClient function to build and answer the invite
-    handleIncomingInvite(action.payload.params)
-  }
-
-  const isVertoInvite = (action: SDKActions) => {
-    if (action.type === 'webrtc.message') {
-      return action.payload.method === 'verto.invite'
-    }
-    return false
-  }
-
-  try {
-    while (true) {
-      // Take all actions from the channel
-      const action: SDKActions = yield sagaEffects.take(
-        swEventChannel,
-        () => true
-      )
-
-      // Fire all the events with fireHoseWorker
-      yield sagaEffects.fork(fireHoseWorker, action)
-
-      // If the event is verto.invite, handle that with vertoInviteWorker
-      if (isVertoInvite(action)) {
-        getLogger().debug('Receiving a call over WebSocket', action)
-        yield sagaEffects.fork(
-          vertoInviteWorker,
-          action as MapToPubSubShape<WebRTCMessageParams>
-        )
-      }
-    }
-  } finally {
-    getLogger().trace('wsClientWorker ended')
-  }
-}

package/src/features/actions.ts

@@ -1,5 +0,0 @@
-import { actions } from '@signalwire/core'
-
-export const audioSetSpeakerAction = actions.createAction<string>(
-  'swJs/audioSetSpeakerAction'
-)

package/src/features/mediaElements/mediaElementsSagas.ts

@@ -1,129 +0,0 @@
-import {
-  getLogger,
-  CustomSagaParams,
-  actions,
-  sagaEffects,
-  LOCAL_EVENT_PREFIX,
-} from '@signalwire/core'
-import type { SagaIterator, Task } from '@signalwire/core'
-import { setMediaElementSinkId } from '@signalwire/webrtc'
-import { setAudioMediaTrack } from '../../utils/audioElement'
-import { audioSetSpeakerAction } from '../actions'
-import { VideoRoomSessionConnection } from '../../video/VideoRoomSession'
-
-export const makeAudioElementSaga = ({ speakerId }: { speakerId?: string }) => {
-  return function* audioElementSaga({
-    instance: room,
-    runSaga,
-  }: CustomSagaParams<VideoRoomSessionConnection>): SagaIterator {
-    if (typeof Audio === 'undefined') {
-      getLogger().warn('`Audio` is not supported on this environment.')
-      return
-    }
-
-    try {
-      const audioEl = room.getAudioEl()
-      let audioTask: Task | undefined
-
-      const trackHandler = function (event: RTCTrackEvent) {
-        switch (event.track.kind) {
-          case 'audio': {
-            audioTask = runSaga(audioElementSetupWorker, {
-              track: event.track,
-              element: audioEl,
-              speakerId,
-              room,
-            })
-            break
-          }
-        }
-      }
-      /**
-       * Using `on` instead of `once` (or `off` within trackHandler) because
-       * there are cases (promote/demote) where we need to handle multiple `track`
-       * events and update the audioEl with the new track.
-       */
-      room.on('track', trackHandler)
-
-      room.once('destroy', () => {
-        audioTask?.cancel()
-      })
-    } catch (error) {
-      getLogger().error('audioElementSaga', error)
-    }
-  }
-}
-
-function* audioElementActionsWatcher({
-  element,
-  room,
-}: {
-  element: HTMLAudioElement
-  room: VideoRoomSessionConnection
-}): SagaIterator {
-  // TODO: For now we're handling individual actions but in the future
-  // we might want to have a single action per custom saga and use it
-  // in a similar fashion to `executeAction`
-  const setSpeakerActionType = actions.getCustomSagaActionType(
-    room.__uuid,
-    audioSetSpeakerAction
-  )
-
-  while (true) {
-    const action = yield sagaEffects.take([setSpeakerActionType])
-
-    try {
-      switch (action.type) {
-        case setSpeakerActionType:
-          const response = yield sagaEffects.call(
-            setMediaElementSinkId,
-            element,
-            action.payload
-          )
-
-          room.emit(
-            // @ts-expect-error
-            `${LOCAL_EVENT_PREFIX}.speaker.updated`,
-            action.payload
-          )
-
-          room.settleCustomSagaTrigger({
-            dispatchId: action.dispatchId,
-            payload: response,
-            kind: 'resolve',
-          })
-          break
-      }
-    } catch (error) {
-      room.settleCustomSagaTrigger({
-        dispatchId: action.dispatchId,
-        payload: error,
-        kind: 'reject',
-      })
-      getLogger().error(error)
-    }
-  }
-}
-
-function* audioElementSetupWorker({
-  track,
-  element,
-  speakerId,
-  room,
-}: {
-  track: MediaStreamTrack
-  element: HTMLAudioElement
-  speakerId?: string
-  room: VideoRoomSessionConnection
-}): SagaIterator {
-  setAudioMediaTrack({ track, element })
-  if (speakerId) {
-    // Catch no-op since setMediaElementSinkId already provides logs
-    setMediaElementSinkId(element, speakerId).catch(() => {})
-  }
-
-  yield sagaEffects.fork(audioElementActionsWatcher, {
-    element,
-    room,
-  })
-}

package/src/index.test.ts

@@ -1,5 +0,0 @@
-describe('Web Entry Point', () => {
-  it('should work', () => {
-    expect(1).toEqual(1)
-  })
-})

package/src/index.ts

@@ -1,153 +0,0 @@
-/**
- * Welcome to the technical documentation for the JavaScript SDK.
- *
- * At the outer level, when you import the SignalWire JS library you get access
- * to three different namespaces:
- *
- *  - {@link Video}
- *  - {@link Chat}
- *  - {@link WebRTC}
- *
- * Video gives you access to the classes and methods that let you
- * interface with the backend Video APIs. Chat gives you access to the classes and functions that you need to create a real-time chat application. WebRTC
- * contains several functions that are useful for interacting with the hardware of the user's device.
- *
- *
- * Don't know where to start? Create an instance of
- * {@link Video.RoomSession} to join a room, use the {@link Chat.Client} constructor to start a chat application, or take a look at [Getting Started
- * with the SignalWire Video
- * API](https://developer.signalwire.com/apis/docs/getting-started-with-the-signalwire-video-api-1).
- *
- * @module
- */
-
-import type {
-  VideoRoomSessionEventNames,
-  RoomStarted,
-  RoomSubscribed,
-  RoomUpdated,
-  RoomEnded,
-  VideoMemberEntity,
-} from '@signalwire/core'
-
-/** @ignore @deprecated */
-export type RoomStartedEventName = RoomStarted
-/** @ignore @deprecated */
-export type RoomEndedEventName = RoomEnded
-/** @ignore @deprecated */
-export type RoomSubscribedEventName = RoomSubscribed
-/** @ignore @deprecated */
-export type RoomUpdatedEventName = RoomUpdated
-/** @ignore @deprecated */
-export type RoomEvent = VideoRoomSessionEventNames
-/** @ignore @deprecated */
-export type RoomMember = VideoMemberEntity & { type: 'member' }
-/** @ignore @deprecated */
-export type RoomScreenShare = VideoMemberEntity & { type: 'screen' }
-/** @ignore @deprecated */
-export type RoomDevice = VideoMemberEntity & { type: 'device' }
-
-/**
- * The Chat namespace contains the classes and functions that you need to
- * create a real-time chat application.
- */
-export * as Chat from './chat'
-
-export * as PubSub from './pubSub'
-
-/**
- * The Fabric namespace contains the classes and functions that you need to
- * create a unified communication application that includes Audio/Video calling
- * with Chat/Messaging capabilties.
- */
-export * as Fabric from './fabric'
-export { SignalWire } from './fabric'
-export * from './fabric'
-
-/**
- * The Video namespace contains the classes and functions that you need to
- * create a video conferencing application.
- */
-export * as Video from './video'
-export { VideoRoomSession } from './video'
-export { RoomSessionScreenShare } from './RoomSessionScreenShare'
-export { RoomSessionDevice } from './RoomSessionDevice'
-
-/**
- * The WebRTC namespace includes functions that give you access to the input and
- * output media devices available on the user's machine. For example, you can
- * use these functions to request permission and get access to the media stream
- * from a webcam, from a microphone, or from a screen sharing.
- */
-export * as WebRTC from './webrtc'
-
-export type {
-  BaseComponentOptions,
-  BaseConnectionState,
-  ClientEvents,
-  EmitterContract,
-  RTCTrackEventName,
-  UserOptions,
-  SessionStatus,
-  SessionEvents,
-  VideoLayout,
-  InternalVideoLayout,
-  VideoLayoutEventNames,
-  VideoLayoutChangedEventParams,
-  VideoRoomSessionEventNames,
-  VideoRoomEventParams,
-  VideoRoomSubscribedEventParams,
-  VideoMemberEntity,
-  VideoMemberEventNames,
-  MemberTalkingEventNames,
-  VideoMemberTalkingEventParams,
-  InternalVideoMemberEntity,
-  InternalVideoLayoutLayer,
-  VideoPosition,
-  VideoPositions,
-  /**
-   * Call Fabric types
-   */
-  CallUpdatedEventParams,
-  CallLeftEventParams,
-  CallStateEventParams,
-  CallPlayEventParams,
-  CallConnectEventParams,
-  CallRoomEventParams,
-  FabricRoomEventParams,
-  FabricLayoutChangedEventParams,
-  FabricMemberJoinedEventParams,
-  FabricMemberUpdatedEventParams,
-  FabricMemberLeftEventParams,
-  FabricMemberTalkingEventParams,
-  FabricMemberEventParams,
-  FabricMemberEntity,
-  InternalFabricMemberEntity,
-  ConversationMessageEventName,
-  ConversationMessageEvent,
-  ConversationEventParams,
-  ConversationEvent,
-  SetAudioFlagsParams,
-} from '@signalwire/core'
-
-export type {
-  BaseConnectionOptions,
-  ConnectionOptions,
-} from '@signalwire/webrtc'
-
-export type {
-  CallJoinedEventParams,
-  RoomSessionObjectEventsHandlerMap,
-  RoomSessionObjectEvents,
-  // Just to keep backwards compatibility.
-  RoomSessionObjectEventsHandlerMap as RoomObjectEventsHandlerMap,
-  RoomSessionObjectEvents as RoomObjectEvents,
-  RoomEventNames,
-  StartScreenShareOptions,
-} from './utils/interfaces'
-
-/**
- * Build Video Element
- */
-export { buildVideoElement } from './buildVideoElement'
-export { LocalVideoOverlay, OverlayMap, UserOverlay } from './VideoOverlays'

package/src/joinRoom.ts

@@ -1,29 +0,0 @@
-import { CreateRoomObjectOptions, createRoomObject } from './createRoomObject'
-
-/**
- * Using Video.joinRoom() you can automatically join a room.
- *
- * @example
- * With an HTMLDivElement with id="root" in the DOM.
- * ```js
- * // <div id="root"></div>
- *
- * try {
- *   const roomObj = await Video.joinRoom({
- *     token: '<YourJWT>',
- *     rootElementId: 'root',
- *   })
- *
- *   // You have joined the room..
- * } catch (error) {
- *   console.error('Error', error)
- * }
- * ```
- * @deprecated Use {@link RoomSession} instead.
- */
-export const joinRoom = (roomOptions: CreateRoomObjectOptions) => {
-  return createRoomObject({
-    ...roomOptions,
-    autoJoin: true,
-  })
-}