@signalwire/js 3.29.2 → 4.0.0-dev-20260220205014

package/src/Client.ts

@@ -1,193 +0,0 @@
-import {
-  BaseClient,
-  ClientEvents,
-  ClientContract,
-  actions,
-  Chat as ChatNamespace,
-  PubSub as PubSubNamespace,
-} from '@signalwire/core'
-import type { CustomSaga } from '@signalwire/core'
-import { ConnectionOptions } from '@signalwire/webrtc'
-import { makeAudioElementSaga } from './features/mediaElements/mediaElementsSagas'
-import { VideoManager, createVideoManagerObject } from './cantina'
-import type { Client as ChatClient } from './chat/Client'
-import type { Client as PubSubClient } from './pubSub/Client'
-import type { RoomSession } from './video/RoomSession'
-import { buildVideoElement } from './buildVideoElement'
-import {
-  createVideoRoomSessionObject,
-  VideoRoomSessionConnection,
-} from './video/VideoRoomSession'
-import { CallParams } from './fabric/interfaces'
-
-export interface Client<RoomSessionType = RoomSession>
-  extends ClientContract<Client<RoomSessionType>, ClientEvents> {
-  rooms: ClientAPI['rooms']
-  chat: ClientAPI['chat']
-  pubSub: ClientAPI['pubSub']
-}
-
-export interface MakeRoomOptions extends CallParams, ConnectionOptions {
-  /** Local media stream to override the local video and audio stream tracks */
-  localStream?: MediaStream
-}
-
-export class ClientAPI extends BaseClient<ClientEvents> {
-  private _videoManager: VideoManager
-  private _chat: ChatClient
-  private _pubSub: PubSubClient
-
-  get rooms() {
-    return {
-      makeRoomObject: (makeRoomOptions: MakeRoomOptions) => {
-        const {
-          rootElement,
-          applyLocalVideoOverlay = true,
-          applyMemberOverlay = true,
-          mirrorLocalVideoOverlay = true,
-          stopCameraWhileMuted = true,
-          stopMicrophoneWhileMuted = true,
-          ...options
-        } = makeRoomOptions
-
-        // TODO: This might not be needed here. We can initiate these sagas in the BaseRoomSession constructor.
-        const customSagas: Array<CustomSaga<VideoRoomSessionConnection>> = []
-
-        /**
-         * By default the SDK will attach the audio to
-         * an Audio element (regardless of "rootElement")
-         */
-        customSagas.push(
-          makeAudioElementSaga({
-            speakerId: options.speakerId,
-          })
-        )
-
-        const room = createVideoRoomSessionObject({
-          ...options,
-          store: this.store,
-          customSagas,
-        })
-
-        /**
-         * If the user provides a `rootElement` we'll
-         * automatically handle the Video element for them
-         */
-        if (rootElement) {
-          try {
-            buildVideoElement({
-              applyLocalVideoOverlay,
-              applyMemberOverlay,
-              mirrorLocalVideoOverlay,
-              room,
-              rootElement,
-            })
-          } catch (error) {
-            this.logger.error('Unable to build the video element automatically')
-          }
-        }
-
-        /**
-         * If the user joins with `join_video_muted: true` or
-         * `join_audio_muted: true` we'll stop the streams
-         * right away.
-         */
-        room.on('room.subscribed', (params) => {
-          const member = params.room_session.members?.find(
-            (m) => m.id === room.memberId
-          )
-
-          if (member?.audio_muted) {
-            try {
-              room.stopOutboundAudio()
-            } catch (error) {
-              this.logger.error('Error handling audio_muted', error)
-            }
-          }
-
-          if (member?.video_muted) {
-            try {
-              room.stopOutboundVideo()
-            } catch (error) {
-              this.logger.error('Error handling video_muted', error)
-            }
-          }
-        })
-
-        /**
-         * Stop and Restore outbound audio on audio_muted event
-         */
-        if (stopMicrophoneWhileMuted) {
-          room.on('member.updated.audio_muted', ({ member }) => {
-            try {
-              if (member.id === room.memberId && 'audio_muted' in member) {
-                member.audio_muted
-                  ? room.stopOutboundAudio()
-                  : room.restoreOutboundAudio()
-              }
-            } catch (error) {
-              this.logger.error('Error handling audio_muted', error)
-            }
-          })
-        }
-
-        /**
-         * Stop and Restore outbound video on video_muted event
-         */
-        if (stopCameraWhileMuted) {
-          room.on('member.updated.video_muted', ({ member }) => {
-            try {
-              if (member.id === room.memberId && 'video_muted' in member) {
-                member.video_muted
-                  ? room.stopOutboundVideo()
-                  : room.restoreOutboundVideo()
-              }
-            } catch (error) {
-              this.logger.error('Error handling video_muted', error)
-            }
-          })
-        }
-
-        return room
-      },
-    }
-  }
-
-  get chat() {
-    if (!this._chat) {
-      this._chat = ChatNamespace.createBaseChatObject<ChatClient>({
-        store: this.store,
-      })
-    }
-    return this._chat
-  }
-
-  get pubSub() {
-    if (!this._pubSub) {
-      this._pubSub = PubSubNamespace.createBasePubSubObject<PubSubClient>({
-        store: this.store,
-      })
-    }
-    return this._pubSub
-  }
-
-  /** @internal */
-  get videoManager() {
-    if (!this._videoManager) {
-      this._videoManager = createVideoManagerObject(this.options)
-    }
-    return this._videoManager
-  }
-
-  /**
-   * Reauthenticate with the SignalWire network using a new token
-   * For now it returns void since with an invalid token the server
-   * will close the connection right away so we can hook on the session
-   * events in case. Need to improve it.
-   *
-   * @internal
-   */
-  reauthenticate(token: string) {
-    this.store.dispatch(actions.reauthAction({ token }))
-  }
-}

package/src/JWTSession.test.ts

@@ -1,60 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import { JWTSession } from './JWTSession'
-
-describe('JWTSession', () => {
-  it('should give priority to the host coming from the JWT (if present)', () => {
-    const tokenWithCH =
-      'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCIsImNoIjoiZXhhbXBsZS5ob3N0LmRvbWFpbi5jb20ifQ.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.G7CvxKKQV44kk3wdiKaq2VYOb2UayJBpKKPXn_84j9E'
-    const session = new JWTSession({
-      token: tokenWithCH,
-    })
-
-    expect(session.host).toBe('wss://example.host.domain.com')
-
-    const tokenWithoutCH =
-      'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'
-    const sessionTwo = new JWTSession({
-      token: tokenWithoutCH,
-    })
-
-    expect(sessionTwo.host).toBe('wss://relay.signalwire.com')
-  })
-
-  it('should override the host option with the connection host header from the token)', () => {
-    const session = new JWTSession({
-      host: 'ws://localhost:8080',
-      token:
-        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCIsImNoIjoiZXhhbXBsZS5ob3N0LmRvbWFpbi5jb20ifQ.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.G7CvxKKQV44kk3wdiKaq2VYOb2UayJBpKKPXn_84j9E',
-    })
-
-    expect(session.host).toBe('wss://example.host.domain.com')
-  })
-
-  it('should fallback to `host` if the `cf` header coming on the JWT is not there or invalid', () => {
-    const sessionOne = new JWTSession({
-      host: 'ws://localhost:8080',
-      token:
-        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c',
-    })
-
-    const sessionTwo = new JWTSession({
-      host: 'ws://localhost:8080',
-      token: '<invalid-jwt>',
-    })
-
-    expect(sessionOne.host).toBe('ws://localhost:8080')
-    expect(sessionTwo.host).toBe('ws://localhost:8080')
-  })
-
-  it('should fallback to the default host if either `host` or `jwt.header.cf` are not defined', () => {
-    const session = new JWTSession({
-      token:
-        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c',
-    })
-
-    expect(session.host).toBe('wss://relay.signalwire.com')
-  })
-})

package/src/JWTSession.ts

@@ -1,146 +0,0 @@
-import jwtDecode from 'jwt-decode'
-import {
-  BaseJWTSession,
-  getLogger,
-  SessionOptions,
-  SwAuthorizationState,
-  type SWCloseEvent,
-} from '@signalwire/core'
-import { getStorage, sessionStorageManager } from './utils/storage'
-import { SwCloseEvent } from './utils/CloseEvent'
-
-type JWTHeader = { ch?: string; typ?: string }
-
-export class JWTSession extends BaseJWTSession {
-  public WebSocketConstructor = WebSocket
-  public CloseEventConstructor = SwCloseEvent
-  public agent = process.env.SDK_PKG_AGENT!
-
-  private tokenTyp: string
-
-  constructor(public options: SessionOptions) {
-    let decodedJwt: JWTHeader = {}
-    try {
-      decodedJwt = jwtDecode(options.token, {
-        header: true,
-      })
-    } catch (e) {
-      if (process.env.NODE_ENV !== 'production') {
-        getLogger().debug('[JWTSession] error decoding the JWT')
-      }
-    }
-
-    super({
-      ...options,
-      host: decodedJwt?.ch || options.host,
-    })
-    this.tokenTyp = decodedJwt.typ ?? 'VRT'
-  }
-
-  get allowReattach() {
-    // @ts-expect-error
-    return this.options?.reattach !== false && (this.isVRT() || this.isSAT())
-  }
-
-  override async retrieveRelayProtocol() {
-    if (!this.allowReattach) {
-      return ''
-    }
-
-    const { protocolKey } = sessionStorageManager(this.options.token)
-    if (protocolKey) {
-      this.logger.trace('Search protocol for', protocolKey)
-      return getStorage()?.getItem(protocolKey) ?? ''
-    }
-    return ''
-  }
-
-  override async persistRelayProtocol() {
-    if (!this.allowReattach) {
-      return
-    }
-
-    const { protocolKey } = sessionStorageManager(this.options.token)
-    if (protocolKey) {
-      this.logger.trace('Persist protocol', protocolKey, this.relayProtocol)
-      getStorage()?.setItem(protocolKey, this.relayProtocol)
-    }
-  }
-
-  override removeRelayProtocol() {
-    const { protocolKey } = sessionStorageManager(this.options.token)
-    if (protocolKey) {
-      this.logger.debug('Remove protocol', protocolKey, this.relayProtocol)
-      getStorage()?.removeItem(protocolKey)
-    }
-  }
-
-  override removePrevCallId() {
-    const { callIdKey } = sessionStorageManager(this.options.token)
-    if (callIdKey) {
-      this.logger.debug('Remove Call', callIdKey)
-      getStorage()?.removeItem(callIdKey)
-    }
-  }
-
-  protected override async retrieveSwAuthorizationState() {
-    const { authStateKey } = sessionStorageManager(this.options.token)
-    if (authStateKey) {
-      return getStorage()?.getItem(authStateKey) ?? ''
-    }
-    return ''
-  }
-
-  protected override async persistSwAuthorizationState(
-    state: SwAuthorizationState
-  ) {
-    if (!this.allowReattach) {
-      return
-    }
-
-    const { authStateKey } = sessionStorageManager(this.options.token)
-    if (authStateKey) {
-      this.logger.trace('Persist auth state', authStateKey, state)
-      getStorage()?.setItem(authStateKey, state)
-    }
-  }
-
-  override removeSwAuthorizationState() {
-    const { authStateKey } = sessionStorageManager(this.options.token)
-    if (authStateKey) {
-      this.logger.trace('Remove auth state', authStateKey)
-      getStorage()?.removeItem(authStateKey)
-    }
-  }
-
-  protected override _onSocketClose(event: SWCloseEvent) {
-    if (this.status === 'disconnected') {
-      const { protocolKey, authStateKey, callIdKey } = sessionStorageManager(
-        this.options.token
-      )
-      this.logger.debug('Cleaning up storage')
-      if (protocolKey) {
-        this.logger.debug('Remove protocolKey', protocolKey)
-        getStorage()?.removeItem(protocolKey)
-      }
-      if (authStateKey) {
-        this.logger.debug('Remove authStateKey', authStateKey)
-        getStorage()?.removeItem(authStateKey)
-      }
-      if (callIdKey) {
-        this.logger.debug('Remove callIdKey', callIdKey)
-        getStorage()?.removeItem(callIdKey)
-      }
-    }
-
-    super._onSocketClose(event)
-  }
-
-  private isVRT() {
-    return this.tokenTyp === 'VRT'
-  }
-
-  private isSAT() {
-    return this.tokenTyp === 'SAT'
-  }
-}

package/src/RoomSessionDevice.test.ts

@@ -1,25 +0,0 @@
-import { RoomSessionDeviceAPI } from './RoomSessionDevice'
-import type { RoomSessionDevice } from './RoomSessionDevice'
-import { configureJestStore } from './testUtils'
-
-describe('RoomDevice Object', () => {
-  let roomDevice: RoomSessionDevice
-
-  beforeEach(() => {
-    roomDevice = new RoomSessionDeviceAPI({
-      store: configureJestStore(),
-    }) as any as RoomSessionDevice
-    // @ts-expect-error
-    roomDevice.execute = jest.fn()
-  })
-
-  it('should have all the custom methods defined', () => {
-    expect(roomDevice.audioMute).toBeDefined()
-    expect(roomDevice.audioUnmute).toBeDefined()
-    expect(roomDevice.videoMute).toBeDefined()
-    expect(roomDevice.videoUnmute).toBeDefined()
-    expect(roomDevice.setMicrophoneVolume).toBeDefined()
-    expect(roomDevice.setInputVolume).toBeDefined()
-    expect(roomDevice.setInputSensitivity).toBeDefined()
-  })
-})

package/src/RoomSessionDevice.ts

@@ -1,62 +0,0 @@
-import {
-  Rooms,
-  extendComponent,
-  BaseConnectionContract,
-  RoomLeft,
-  RoomLeftEventParams,
-  BaseConnectionState,
-} from '@signalwire/core'
-import { BaseConnection, MediaEventNames } from '@signalwire/webrtc'
-import { RoomSessionDeviceMethods } from './utils/interfaces'
-
-type RoomSessionDeviceEventsHandlerMap = Record<
-  BaseConnectionState,
-  (params: RoomSessionDevice) => void
-> &
-  Record<RoomLeft, (params?: RoomLeftEventParams) => void> &
-  Record<MediaEventNames, () => void>
-
-export type RoomSessionDeviceEvents = {
-  [k in keyof RoomSessionDeviceEventsHandlerMap]: RoomSessionDeviceEventsHandlerMap[k]
-}
-
-/** @deprecated Use {@link RoomSessionDevice} instead */
-export interface RoomDevice extends RoomSessionDevice {}
-export interface RoomSessionDevice
-  extends RoomSessionDeviceMethods,
-    BaseConnectionContract<RoomSessionDeviceEvents> {
-  join(): Promise<void>
-  leave(): Promise<void>
-  /** @internal */
-  runWorker: BaseConnection<RoomSessionDeviceEvents>['runWorker']
-}
-
-export class RoomSessionDeviceConnection extends BaseConnection<RoomSessionDeviceEvents> {
-  join() {
-    return super.invite()
-  }
-
-  leave() {
-    return super.hangup()
-  }
-}
-
-/**
- * A RoomSessionDevice represents a device (such as a microphone or a camera)
- * that is at some point in its lifetime part of a {@link RoomSession}. You can
- * obtain a RoomSessionDevice from the {@link RoomSession} methods
- * {@link RoomSession.addCamera}, {@link RoomSession.addMicrophone}, and
- * {@link RoomSession.addDevice}.
- */
-export const RoomSessionDeviceAPI = extendComponent<
-  RoomSessionDeviceConnection,
-  RoomSessionDeviceMethods
->(RoomSessionDeviceConnection, {
-  audioMute: Rooms.audioMuteMember,
-  audioUnmute: Rooms.audioUnmuteMember,
-  videoMute: Rooms.videoMuteMember,
-  videoUnmute: Rooms.videoUnmuteMember,
-  setInputVolume: Rooms.setInputVolumeMember,
-  setMicrophoneVolume: Rooms.setInputVolumeMember,
-  setInputSensitivity: Rooms.setInputSensitivityMember,
-})

package/src/RoomSessionScreenShare.test.ts

@@ -1,25 +0,0 @@
-import { RoomSessionScreenShareAPI } from './RoomSessionScreenShare'
-import type { RoomSessionScreenShare } from './RoomSessionScreenShare'
-import { configureJestStore } from './testUtils'
-
-describe('RoomScreenShare Object', () => {
-  let roomScreenShare: RoomSessionScreenShare
-
-  beforeEach(() => {
-    roomScreenShare = new RoomSessionScreenShareAPI({
-      store: configureJestStore(),
-    }) as any as RoomSessionScreenShare
-    // @ts-expect-error
-    roomScreenShare.execute = jest.fn()
-  })
-
-  it('should have all the custom methods defined', () => {
-    expect(roomScreenShare.audioMute).toBeDefined()
-    expect(roomScreenShare.audioUnmute).toBeDefined()
-    expect(roomScreenShare.videoMute).toBeDefined()
-    expect(roomScreenShare.videoUnmute).toBeDefined()
-    expect(roomScreenShare.setMicrophoneVolume).toBeDefined()
-    expect(roomScreenShare.setInputVolume).toBeDefined()
-    expect(roomScreenShare.setInputSensitivity).toBeDefined()
-  })
-})

package/src/RoomSessionScreenShare.ts

@@ -1,58 +0,0 @@
-import {
-  Rooms,
-  extendComponent,
-  BaseConnectionContract,
-  RoomLeft,
-  RoomLeftEventParams,
-  BaseConnectionState,
-} from '@signalwire/core'
-import { BaseConnection, MediaEventNames } from '@signalwire/webrtc'
-import { RoomScreenShareMethods } from './utils/interfaces'
-
-type RoomSessionScreenShareEventsHandlerMap = Record<
-  BaseConnectionState,
-  (params: RoomSessionScreenShare) => void
-> &
-  Record<RoomLeft, (params?: RoomLeftEventParams) => void> &
-  Record<MediaEventNames, () => void>
-
-export type RoomSessionScreenShareEvents = {
-  [k in keyof RoomSessionScreenShareEventsHandlerMap]: RoomSessionScreenShareEventsHandlerMap[k]
-}
-
-/** @deprecated Use {@link RoomSessionScreenShare} instead */
-export interface RoomScreenShare extends RoomSessionScreenShare {}
-export interface RoomSessionScreenShare
-  extends RoomScreenShareMethods,
-    BaseConnectionContract<RoomSessionScreenShareEvents> {
-  join(): Promise<void>
-  leave(): Promise<void>
-  /** @internal */
-  runWorker: BaseConnection<RoomSessionScreenShareEvents>['runWorker']
-}
-
-export class RoomSessionScreenShareConnection extends BaseConnection<RoomSessionScreenShareEvents> {
-  join() {
-    return super.invite()
-  }
-
-  leave() {
-    return super.hangup()
-  }
-}
-
-/**
- * Represents a screen sharing.
- */
-export const RoomSessionScreenShareAPI = extendComponent<
-  RoomSessionScreenShareConnection,
-  RoomScreenShareMethods
->(RoomSessionScreenShareConnection, {
-  audioMute: Rooms.audioMuteMember,
-  audioUnmute: Rooms.audioUnmuteMember,
-  videoMute: Rooms.videoMuteMember,
-  videoUnmute: Rooms.videoUnmuteMember,
-  setMicrophoneVolume: Rooms.setInputVolumeMember,
-  setInputVolume: Rooms.setInputVolumeMember,
-  setInputSensitivity: Rooms.setInputSensitivityMember,
-})