@signalwire/js 3.29.2 → 4.0.0-beta.1

package/src/fabric/utils/eventMappers.ts

@@ -1,184 +0,0 @@
-import {
-  CallJoinedEvent,
-  CallJoinedEventParams,
-  FabricLayoutChangedEvent,
-  FabricMemberJoinedEvent,
-  FabricMemberJoinedEventParams,
-  FabricMemberLeftEvent,
-  FabricMemberLeftEventParams,
-  FabricMemberTalkingEvent,
-  FabricMemberTalkingEventParams,
-  FabricMemberUpdatedEvent,
-  FabricMemberUpdatedEventParams,
-  InternalFabricMemberEntity,
-  InternalFabricMemberEntityUpdated,
-  InternalVideoMemberEntity,
-  InternalVideoMemberEntityUpdated,
-  MapToPubSubShape,
-  VideoLayoutChangedEvent,
-  VideoMemberJoinedEvent,
-  VideoMemberJoinedEventParams,
-  VideoMemberLeftEvent,
-  VideoMemberLeftEventParams,
-  VideoMemberTalkingEvent,
-  VideoMemberTalkingEventParams,
-  VideoMemberUpdatedEvent,
-  VideoMemberUpdatedEventParams,
-} from '@signalwire/core'
-
-/**
- * Map the InternalFabricMemberEntity to InternalVideoMemberEntity
- */
-export const mapInternalFabricMemberToInternalVideoMemberEntity = (
-  params: InternalFabricMemberEntity
-): InternalVideoMemberEntity => {
-  return {
-    ...params,
-    id: params.member_id,
-  }
-}
-
-/**
- * Map the InternalFabricMemberEntityUpdated to InternalVideoMemberEntityUpdated
- */
-export const mapInternalFabricMemberToInternalVideoMemberUpdatedEntity = (
-  params: InternalFabricMemberEntityUpdated
-): InternalVideoMemberEntityUpdated => {
-  return {
-    ...mapInternalFabricMemberToInternalVideoMemberEntity(params),
-    updated: params.updated.map((key) =>
-      key === 'member_id' ? 'id' : (key as keyof InternalVideoMemberEntity)
-    ),
-  }
-}
-
-/**
- * Map the "call.joined" event params to "video.room.subscribed" event params
- */
-export const mapCallJoinedToRoomSubscribedEventParams = (
-  params: CallJoinedEventParams
-) => {
-  return {
-    ...params,
-    room: {
-      ...params.room_session,
-      members: params.room_session.members.map(
-        mapInternalFabricMemberToInternalVideoMemberEntity
-      ),
-    },
-    room_session: {
-      ...params.room_session,
-      members: params.room_session.members.map(
-        mapInternalFabricMemberToInternalVideoMemberEntity
-      ),
-    },
-  }
-}
-
-/**
- * Map the "call.joined" action to "video.room.subscribed" action
- */
-export const mapCallJoinedToRoomSubscribedAction = (
-  action: MapToPubSubShape<CallJoinedEvent>
-) => {
-  return {
-    type: `video.room.subscribed`,
-    payload: mapCallJoinedToRoomSubscribedEventParams(action.payload),
-  }
-}
-
-/**
- * Map the "member.joined" and "member.left" event params
- * to "video.member.joined" and "video.member.left"  event params
- */
-export const mapFabricMemberToVideoMemberJoinAndLeftEventParams = (
-  params: FabricMemberJoinedEventParams | FabricMemberLeftEventParams
-): VideoMemberJoinedEventParams | VideoMemberLeftEventParams => {
-  return {
-    room_session_id: params.room_session_id,
-    room_id: params.room_id,
-    member: mapInternalFabricMemberToInternalVideoMemberEntity(params.member),
-  }
-}
-
-/**
- * Map the "member.joined" and "member.left" actions
- * to "video.member.joined" and "video.member.left"  actions
- */
-export const mapFabricMemberActionToVideoMemberJoinAndLeftAction = (
-  action: MapToPubSubShape<FabricMemberJoinedEvent | FabricMemberLeftEvent>
-): MapToPubSubShape<VideoMemberJoinedEvent | VideoMemberLeftEvent> => {
-  return {
-    type: `video.${action.type}`,
-    payload: mapFabricMemberToVideoMemberJoinAndLeftEventParams(action.payload),
-  }
-}
-
-/**
- * Map the "member.updated" event params to "video.member.updated"  event params
- */
-export const mapFabricMemberEventToVideoMemberUpdatedEventParams = (
-  params: FabricMemberUpdatedEventParams
-): VideoMemberUpdatedEventParams => {
-  return {
-    room_session_id: params.room_session_id,
-    room_id: params.room_id,
-    member: mapInternalFabricMemberToInternalVideoMemberUpdatedEntity(
-      params.member
-    ),
-  }
-}
-
-/**
- * Map the "member.updated" action to "video.member.updated"  action
- */
-export const mapFabricMemberActionToVideoMemberUpdatedAction = (
-  action: MapToPubSubShape<FabricMemberUpdatedEvent>
-): MapToPubSubShape<VideoMemberUpdatedEvent> => {
-  return {
-    type: `video.${action.type}`,
-    payload: mapFabricMemberEventToVideoMemberUpdatedEventParams(
-      action.payload
-    ),
-  }
-}
-
-/**
- * Map the "member.talking" event params to "video.member.talking"  event params
- */
-export const mapFabricMemberToVideoMemberTalkingEventParams = (
-  params: FabricMemberTalkingEventParams
-): VideoMemberTalkingEventParams => {
-  return {
-    room_session_id: params.room_session_id,
-    room_id: params.room_id,
-    member: {
-      ...params.member,
-      id: params.member.member_id,
-    },
-  }
-}
-
-/**
- * Map the "member.talking" action to "video.member.talking"  action
- */
-export const mapFabricMemberActionToVideoMemberTalkingAction = (
-  action: MapToPubSubShape<FabricMemberTalkingEvent>
-): MapToPubSubShape<VideoMemberTalkingEvent> => {
-  return {
-    type: `video.${action.type}`,
-    payload: mapFabricMemberToVideoMemberTalkingEventParams(action.payload),
-  }
-}
-
-/**
- * Map the "layout.changed" action to "video.layout.changed"  action
- */
-export const mapFabricLayoutActionToVideoLayoutAction = (
-  action: MapToPubSubShape<FabricLayoutChangedEvent>
-): MapToPubSubShape<VideoLayoutChangedEvent> => {
-  return {
-    type: `video.${action.type}`,
-    payload: action.payload,
-  }
-}

package/src/fabric/utils/typeGuard.ts

@@ -1,31 +0,0 @@
-import {
-  GetAddressParams,
-  GetAddressByNameParams,
-  GetAddressByIdParams,
-  GetAddressResponse,
-  GetAddressesResponse,
-} from '../interfaces'
-
-export const isGetAddressByNameParams = (
-  obj: GetAddressParams
-): obj is GetAddressByNameParams => {
-  return obj && 'name' in obj
-}
-
-export const isGetAddressByIdParams = (
-  obj: GetAddressParams
-): obj is GetAddressByIdParams => {
-  return obj && 'id' in obj
-}
-
-export const isGetAddressResponse = (
-  obj: GetAddressResponse | GetAddressesResponse
-): obj is GetAddressResponse => {
-  return obj && 'id' in obj && 'name' in obj
-}
-
-export const isGetAddressesResponse = (
-  obj: GetAddressResponse | GetAddressesResponse
-): obj is GetAddressesResponse => {
-  return obj && 'data' in obj
-}

package/src/fabric/utils/validationProxy.ts

@@ -1,83 +0,0 @@
-import {
-  validateAudioMute,
-  validateAudioUnmute,
-  validateDeaf,
-  validateLock,
-  validateRemoveMember,
-  validateSetAudioFlags,
-  validateSetInputSensitivity,
-  validateSetInputVolume,
-  validateSetLayout,
-  validateSetOutputVolume,
-  validateSetPositions,
-  validateSetRaiseHand,
-  validateUndeaf,
-  validateUnlock,
-  validateVideoMute,
-  validateVideoUnmute,
-  validateEnd
-} from './validators'
-import {
-  FabricRoomSession,
-  FabricRoomSessionConnection,
-} from '../FabricRoomSession'
-
-type ValidatorMap = Partial<
-  Record<
-    keyof FabricRoomSession,
-    (this: FabricRoomSessionConnection, ...args: any[]) => void
-  >
->
-
-export const validationsMap: ValidatorMap = {
-  audioMute: validateAudioMute,
-  audioUnmute: validateAudioUnmute,
-  videoMute: validateVideoMute,
-  videoUnmute: validateVideoUnmute,
-  deaf: validateDeaf,
-  undeaf: validateUndeaf,
-  removeMember: validateRemoveMember,
-  setRaisedHand: validateSetRaiseHand,
-  setLayout: validateSetLayout,
-  setInputVolume: validateSetInputVolume,
-  setOutputVolume: validateSetOutputVolume,
-  setInputSensitivity: validateSetInputSensitivity,
-  setPositions: validateSetPositions,
-  lock: validateLock,
-  unlock: validateUnlock,
-  setAudioFlags: validateSetAudioFlags,
-  end: validateEnd,
-}
-
-/**
- * Wraps a FabricRoomSession instance with a Proxy that runs validation
- * functions (from validationsMap) before calling the original method.
- *
- * @param instance - The FabricRoomSession instance to wrap.
- * @returns The proxied FabricRoomSession.
- */
-export function createFabricRoomSessionValidateProxy(
-  instance: FabricRoomSession
-) {
-  return new Proxy(instance, {
-    get(target, prop: keyof FabricRoomSession, receiver) {
-      // Only intercept keys that have an associated validator
-      if (typeof prop === 'string' && prop in validationsMap) {
-        const targetConn = target as unknown as FabricRoomSessionConnection
-        const origMethod = targetConn[prop] as Function
-        if (typeof origMethod === 'function') {
-          // Wrap in a promise so validator runs asynchronously
-          return async function (...args: unknown[]) {
-            // Run the validator before calling the method
-            const validator = validationsMap[prop as keyof FabricRoomSession]
-            if (validator) {
-              validator.apply(targetConn, args)
-            }
-            return origMethod.apply(targetConn, args)
-          }
-        }
-      }
-      return Reflect.get(target, prop, receiver)
-    },
-  })
-}

package/src/fabric/utils/validators.ts

@@ -1,242 +0,0 @@
-import {
-  CapabilityError,
-  MemberCommandParams,
-  MemberCommandWithValueParams,
-  MemberCommandWithVolumeParams,
-  Rooms,
-  SetAudioFlagsParams,
-} from '@signalwire/core'
-import { FabricRoomSessionConnection } from '../FabricRoomSession'
-
-const isSelfMember = (
-  params: MemberCommandParams | undefined,
-  ctx: FabricRoomSessionConnection
-) => {
-  return !params?.memberId || params.memberId === ctx.member.id
-}
-
-export function validateAudioMute(
-  this: FabricRoomSessionConnection,
-  params?: MemberCommandParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self.muteAudio.off
-    : this.capabilities?.member.muteAudio.off
-  if (!capability) {
-    throw new CapabilityError('Missing audio mute capability')
-  }
-}
-
-export function validateAudioUnmute(
-  this: FabricRoomSessionConnection,
-  params?: MemberCommandParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self.muteAudio.on
-    : this.capabilities?.member.muteAudio.on
-  if (!capability) {
-    throw new CapabilityError('Missing audio unmute capability')
-  }
-}
-
-export function validateVideoMute(
-  this: FabricRoomSessionConnection,
-  params?: MemberCommandParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self.muteVideo.off
-    : this.capabilities?.member.muteVideo.off
-  if (!capability) {
-    throw new CapabilityError('Missing video mute capability')
-  }
-}
-
-export function validateVideoUnmute(
-  this: FabricRoomSessionConnection,
-  params?: MemberCommandParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self.muteVideo.on
-    : this.capabilities?.member.muteVideo.on
-  if (!capability) {
-    throw new CapabilityError('Missing video unmute capability')
-  }
-}
-
-export function validateDeaf(
-  this: FabricRoomSessionConnection,
-  params?: MemberCommandParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self.deaf.on
-    : this.capabilities?.member.deaf.on
-  if (!capability) {
-    throw new CapabilityError('Missing deaf capability')
-  }
-}
-
-export function validateUndeaf(
-  this: FabricRoomSessionConnection,
-  params?: MemberCommandParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self.deaf.off
-    : this.capabilities?.member.deaf.off
-  if (!capability) {
-    throw new CapabilityError('Missing undeaf capability')
-  }
-}
-
-export function validateRemoveMember(
-  this: FabricRoomSessionConnection,
-  params: Required<MemberCommandParams>
-) {
-  if (!params?.memberId) {
-    throw new TypeError('Invalid or missing "memberId" argument')
-  }
-  const capability = this.capabilities?.member.remove
-  if (!capability) {
-    throw new CapabilityError('Missing remove member capability')
-  }
-}
-
-export function validateSetRaiseHand(
-  this: FabricRoomSessionConnection,
-  params?: Rooms.SetRaisedHandRoomParams
-) {
-  const { raised = true } = params || {}
-  const self = isSelfMember(params, this)
-  const raiseCap = self
-    ? this.capabilities?.self.raisehand.on
-    : this.capabilities?.member.raisehand.on
-  const lowerCap = self
-    ? this.capabilities?.self.raisehand.off
-    : this.capabilities?.member.raisehand.off
-  if (raised && !raiseCap) {
-    throw new CapabilityError('Missing raisehand capability')
-  }
-  if (!raised && !lowerCap) {
-    throw new CapabilityError('Missing lowerhand capability')
-  }
-}
-
-export function validateSetLayout(this: FabricRoomSessionConnection) {
-  if (!this.capabilities?.setLayout) {
-    throw new CapabilityError('Missing setLayout capability')
-  }
-}
-
-export function validateSetInputVolume(
-  this: FabricRoomSessionConnection,
-  params: MemberCommandWithVolumeParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self?.microphoneVolume
-    : this.capabilities?.member?.microphoneVolume
-  if (!capability) {
-    throw new CapabilityError('Missing setInputVolume capability')
-  }
-  if (params.volume < -50 || params.volume > 50) {
-    throw new RangeError('The volume ranges from -50 to 50')
-  }
-}
-
-export function validateSetOutputVolume(
-  this: FabricRoomSessionConnection,
-  params: MemberCommandWithVolumeParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self?.speakerVolume
-    : this.capabilities?.member?.speakerVolume
-  if (!capability) {
-    throw new CapabilityError('Missing setOutputVolume capability')
-  }
-  if (params.volume < -50 || params.volume > 50) {
-    throw new RangeError('The volume ranges from -50 to 50')
-  }
-}
-
-export function validateSetInputSensitivity(
-  this: FabricRoomSessionConnection,
-  params: MemberCommandWithValueParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self.microphoneSensitivity
-    : this.capabilities?.member.microphoneSensitivity
-  if (!capability) {
-    throw new CapabilityError('Missing setInputSensitivity capability')
-  }
-  if (params.value < 0 || params.value > 100) {
-    throw new RangeError('The sensitivity value ranges from 0 to 100')
-  }
-}
-
-export function validateSetPositions(
-  this: FabricRoomSessionConnection,
-  params: Rooms.SetPositionsParams
-) {
-  if (params.positions && !Object.keys(params.positions).length) {
-    throw new TypeError('Invalid positions specified')
-  }
-  const hasSelfPositions = Object.keys(params.positions).some((p) =>
-    ['self', `${this.memberId}`].includes(p)
-  )
-  const capability = hasSelfPositions
-    ? this.capabilities?.self.position
-    : this.capabilities?.member.position
-  if (!capability) {
-    throw new CapabilityError('Missing setPositions capability')
-  }
-}
-
-export function validateLock(this: FabricRoomSessionConnection) {
-  if (!this.capabilities?.lock.on) {
-    throw new CapabilityError('Missing lock capability')
-  }
-}
-
-export function validateUnlock(this: FabricRoomSessionConnection) {
-  if (!this.capabilities?.lock.off) {
-    throw new CapabilityError('Missing unlock capability')
-  }
-}
-
-export function validateSetAudioFlags(
-  this: FabricRoomSessionConnection,
-  params?: SetAudioFlagsParams
-) {
-  const isSelf = isSelfMember(params, this)
-  const capability = isSelf
-    ? this.capabilities?.self.audioFlags
-    : this.capabilities?.member.audioFlags
-  if (!capability) {
-    throw new CapabilityError('Missing audio flags capability')
-  }
-
-  const { echoCancellation, autoGain, noiseSuppression } = params || {}
-  if (
-    echoCancellation === undefined &&
-    autoGain === undefined &&
-    noiseSuppression === undefined
-  ) {
-    throw new TypeError(
-      'Invalid parameters: you must specify at least one of `echoCancellation`, `autoGain`, or `noiseSuppression`'
-    )
-  }
-}
-
-export function validateEnd(this: FabricRoomSessionConnection) {
-  const capability = this.capabilities?.end
-  if (!capability) {
-    throw new CapabilityError("Missing 'end' capability")
-  }
-}

package/src/fabric/workers/callJoinWorker.ts

@@ -1,88 +0,0 @@
-import {
-  getLogger,
-  SagaIterator,
-  CallJoinedEvent,
-  sagaEffects,
-  MemberPosition,
-  stripNamespacePrefix,
-} from '@signalwire/core'
-import {
-  createFabricRoomSessionMemberObject,
-  FabricRoomSessionMember,
-} from '../FabricRoomSessionMember'
-import { FabricWorkerParams } from './fabricWorker'
-import { fabricMemberWorker } from './fabricMemberWorker'
-import { mapCapabilityPayload } from '../utils/capabilitiesHelpers'
-import { mapCallJoinedToRoomSubscribedEventParams } from '../utils/eventMappers'
-
-export const callJoinWorker = function* (
-  options: FabricWorkerParams<CallJoinedEvent>
-): SagaIterator {
-  getLogger().trace('callJoinWorker started')
-  const { action, instanceMap, instance: cfRoomSession } = options
-  const { payload } = action
-  const { get, set } = instanceMap
-
-  yield sagaEffects.fork(MemberPosition.memberPositionWorker, {
-    ...options,
-    /**
-     * The {@link memberPositionWorker} worker understands only the Video SDK events.
-     * So, we need to map CF SDK event to Video SDK event.
-     * Similar to what we do in the {@link callSegmentWorker}, for member events.
-     */
-    initialState: mapCallJoinedToRoomSubscribedEventParams(payload),
-    dispatcher: function* (subType, subPayload) {
-      /**
-       * The {@link memberPositionWorker} dispatches the Video SDK events.
-       * We need to convert it back to CF SDK event before emitting to the user.
-       */
-      const fabricType = stripNamespacePrefix(subType, 'video') as any
-      const fabricPaylod = {
-        ...subPayload,
-        member: {
-          ...subPayload.member,
-          member_id: subPayload.member.id,
-        },
-      }
-
-      yield sagaEffects.fork(fabricMemberWorker, {
-        ...options,
-        action: { type: fabricType, payload: fabricPaylod },
-      })
-    },
-  })
-
-  payload.room_session.members?.forEach((member: any) => {
-    let memberInstance = get<FabricRoomSessionMember>(member.member_id!)
-    if (!memberInstance) {
-      memberInstance = createFabricRoomSessionMemberObject({
-        store: cfRoomSession.store,
-        payload: {
-          member: member,
-          room_id: payload.room_id,
-          room_session_id: payload.room_session_id,
-        },
-      })
-    } else {
-      memberInstance.setPayload({
-        member: member,
-        room_id: payload.room_id,
-        room_session_id: payload.room_session_id,
-      })
-    }
-    set<FabricRoomSessionMember>(member.member_id, memberInstance)
-  })
-
-  cfRoomSession.member = get<FabricRoomSessionMember>(payload.member_id)
-  // the server send the capabilities payload as an array of string
-  cfRoomSession.capabilities = mapCapabilityPayload(payload.capabilities)
-
-  const fabricEvent = {
-    ...payload,
-    capabilities: cfRoomSession.capabilities,
-  }
-
-  cfRoomSession.emit('call.joined', fabricEvent)
-
-  getLogger().trace('callJoinWorker ended')
-}

package/src/fabric/workers/callLeftWorker.ts

@@ -1,32 +0,0 @@
-import { getLogger, SagaIterator, CallLeftEvent } from '@signalwire/core'
-import { FabricWorkerParams } from './fabricWorker'
-import { FabricRoomSessionMemberAPI } from '../FabricRoomSessionMember'
-
-export const callLeftWorker = function* (
-  options: FabricWorkerParams<CallLeftEvent>
-): SagaIterator {
-  getLogger().trace('callLeftWorker started')
-
-  const {
-    action: { payload },
-    instance: cfRoomSession,
-    instanceMap,
-  } = options
-
-  const { room_session_id } = payload
-
-  // Remove all the member instance where roomSessionId matches
-  instanceMap.getAll().forEach(([key, obj]) => {
-    if (
-      obj instanceof FabricRoomSessionMemberAPI &&
-      obj.roomSessionId === room_session_id
-    ) {
-      instanceMap.remove(key)
-    }
-  })
-
-  cfRoomSession.emit('call.left', payload)
-  cfRoomSession.emit('room.left', payload)
-
-  getLogger().trace('callLeftWorker ended')
-}