@wazo/sdk 0.38.22 → 0.39.0-beta.1

package/src/simple/room/{SipRoom.js → SipRoom.ts}

@@ -1,6 +1,6 @@
-// @flow
-
+import { Invitation, Inviter } from 'sip.js';
 import type { Message } from 'sip.js/lib/api/message';
+import CallSession from '../../domain/CallSession';
 import IssueReporter from '../../service/IssueReporter';
 import Wazo from '../index';
 import Room from './Room';
@@ -8,18 +8,27 @@ import Room from './Room';
 const logger = IssueReporter.loggerFor('sdk-sip-room');
 
 class SipRoom extends Room {
-
-  static async connect({ extension, constraints, audioOnly = false, extra, room }: Object) {
-    logger.info('connecting to sip room', { extension, audioOnly, room: !!room });
+  static async connect({
+    extension,
+    constraints,
+    audioOnly = false,
+    extra,
+    room,
+  }: Record<string, any>) {
+    logger.info('connecting to sip room', {
+      extension,
+      audioOnly,
+      room: !!room,
+    });
 
     if (!room) {
-      await Wazo.Phone.connect({ media: constraints });
-
+      await Wazo.Phone.connect({
+        media: constraints,
+      });
       const withCamera = constraints && !!constraints.video;
-
       const callSession = await Wazo.Phone.call(extension, withCamera, null, audioOnly, true);
       // eslint-disable-next-line no-param-reassign
-      room = new SipRoom(callSession, extension, null, null, extra);
+      room = new SipRoom(callSession as CallSession, extension, null, null, extra);
     }
 
     if (room && room.callSession && room.callSession.call) {
@@ -29,28 +38,24 @@ class SipRoom extends Room {
     logger.info('connected to room', {
       extension: room.extension,
     });
-
     return room;
   }
 
   mute() {
     logger.info('mute sip room');
-
-    Wazo.Phone.mute(this.callSession, false);
-
+    Wazo.Phone.mute(this.callSession as CallSession, false);
     this.sendMuteStatus();
   }
 
   unmute() {
     logger.info('unmute sip room');
-
-    Wazo.Phone.unmute(this.callSession, false);
-
+    Wazo.Phone.unmute(this.callSession as CallSession, false);
     this.sendUnMuteStatus();
   }
 
-  getLocalGuestName() {
-    return Wazo.Phone.phone.client.userAgent.options.displayName;
+  getLocalGuestName(): string | null {
+    // @ts-ignore
+    return Wazo.Phone.phone?.client.userAgent?.options.displayName || null;
   }
 
   // Overridden to not listen to websocket messages
@@ -60,14 +65,13 @@ class SipRoom extends Room {
     Wazo.Phone.on(this.ON_CHAT, this._boundOnChat);
     Wazo.Phone.on(this.ON_SIGNAL, this._boundOnSignal);
     Wazo.Phone.on(this.ON_VIDEO_INPUT_CHANGE, this._boundSaveLocalVideoStream);
-
-    [this.ON_AUDIO_STREAM, this.ON_VIDEO_STREAM, this.ON_REMOVE_STREAM].forEach(event =>
-      Wazo.Phone.on(event, (...args) => this.eventEmitter.emit.apply(this.eventEmitter, [event, ...args])));
+    [this.ON_AUDIO_STREAM, this.ON_VIDEO_STREAM, this.ON_REMOVE_STREAM].forEach(event => Wazo.Phone.on(event, (...args) => this.eventEmitter.emit.apply(this.eventEmitter, [event, ...args])));
   }
 
-  _onMessage(message: Message) {
+  _onMessage(message: Message): Record<string, any> | null | undefined {
     // eslint-disable-next-line no-underscore-dangle
     const body = super._onMessage(message);
+
     if (!body) {
       return;
     }
@@ -76,42 +80,55 @@ class SipRoom extends Room {
 
     switch (body.type) {
       case 'ConfbridgeWelcome':
-        body.channels.forEach(channel => {
+        body.channels.forEach((channel: any) => {
           this._onParticipantJoined(channel);
         });
-
         break;
-      case 'ConfbridgeJoin': {
+
+      case 'ConfbridgeJoin':
+      {
         const channel = getChannel();
+
         this._onParticipantJoined(channel);
+
         break;
       }
-      case 'ConfbridgeLeave': {
+
+      case 'ConfbridgeLeave':
+      {
         const channel = getChannel();
+
         this._onParticipantLeft({
           data: {
             call_id: channel.id,
           },
         });
+
         break;
       }
+
       default:
         break;
     }
   }
 
-  async _onParticipantJoined(channel: Object) {
+  async _onParticipantJoined(channel: Record<string, any>): Promise<any> {
     const isLocal = channel.channelvars.WAZO_SIP_CALL_ID === this._getCurrentSipCallIs();
+
     const callId = channel.id;
     const ParticipantClass = isLocal ? Wazo.LocalParticipant : Wazo.RemoteParticipant;
     const name = channel.caller ? channel.caller.name : null;
-    const extra = isLocal ? { guestName: this.getLocalGuestName() } : {};
+    const extra = isLocal ? {
+      guestName: this.getLocalGuestName(),
+    } : {};
+
     const participant = new ParticipantClass(this, {
       caller_id_name: name,
       call_id: callId,
     }, extra);
 
     const participantIdx = this.participants.findIndex(other => other.callId === participant.callId);
+
     if (participantIdx !== -1 && name) {
       this.participants[participantIdx].name = name;
       return;
@@ -139,7 +156,7 @@ class SipRoom extends Room {
   }
 
   _getCurrentSipCallIs() {
-    return Wazo.Phone.getSipSessionId(Wazo.Phone.phone.currentSipSession);
+    return Wazo.Phone.getSipSessionId(Wazo.Phone.phone?.currentSipSession as Invitation | Inviter);
   }
 
 }

package/src/simple/room/{Stream.js → Stream.ts}

@@ -1,25 +1,26 @@
 /* global document */
+
 /* eslint-disable no-param-reassign */
-// @flow
 import type Participant from './Participant';
 import Wazo from '../index';
 
 class Stream {
   htmlStream: MediaStream;
-  participant: Participant;
+
+  participant: Participant | undefined;
 
   static detachStream(stream: any) {
-    stream.getTracks().forEach(track => {
+    stream.getTracks().forEach((track: any) => {
       track.stop();
     });
   }
 
-  constructor(htmlStream: MediaStream, participant: Participant) {
+  constructor(htmlStream: MediaStream, participant?: Participant) {
     this.htmlStream = htmlStream;
     this.participant = participant;
   }
 
-  attach(rawElement: ?HTMLVideoElement) {
+  attach(rawElement: HTMLVideoElement | null | undefined) {
     const element = rawElement || document.createElement('video');
     const isLocal = this.participant instanceof Wazo.LocalParticipant;
     element.autoplay = true;
@@ -35,7 +36,7 @@ class Stream {
       const tracks = this.htmlStream ? this.htmlStream.getVideoTracks() : [];
       tracks.forEach(track => {
         track.enabled = true;
-        // $FlowFixMe
+        // @ts-ignore
         track.loaded = true;
       });
     };
@@ -58,6 +59,7 @@ class Stream {
   get id() {
     return this.htmlStream ? this.htmlStream.id : null;
   }
+
 }
 
 export default Stream;

package/src/simple/room/__tests__/{Participant.test.js → Participant.test.ts}

@@ -8,70 +8,64 @@ jest.mock('../../../service/getApiClient');
 describe('Participant', () => {
   describe('ban', () => {
     it('should throw an error when there is no meeting', async () => {
+      // @ts-expect-error
       const room = new Room();
       const participant = new Wazo.RemoteParticipant(room, {
         call_id: 'id',
         caller_id_name: 'Alice',
         caller_id_number: 'number',
+        user_uuid: 'some_uuid',
       });
-
-      await expect(async () => participant.ban())
-        .rejects.toThrow('Attempting to ban a participant without a `meetingUuid`');
+      await expect(async () => participant.ban()).rejects.toThrow('Attempting to ban a participant without a `meetingUuid`');
     });
-
     it('should call the api', async () => {
       const number = '1234';
       const meetingUuid = 'some-meeting-uuid';
       const callId = 'some-call-id';
+      // @ts-expect-error
       const room = new Room();
       room.setMeetingUuid(meetingUuid);
-
       const banMeetingParticipant = jest.fn();
-
+      // @ts-expect-error
       getApiClient.mockImplementation(() => ({
         calld: {
           banMeetingParticipant,
         },
       }));
-
       const participant = new Wazo.RemoteParticipant(room, {
         call_id: callId,
         caller_id_name: 'Alice',
         caller_id_number: number,
+        user_uuid: 'some_uuid',
       });
-
       participant.onBan = jest.fn();
-
       await participant.ban();
       expect(banMeetingParticipant).toHaveBeenCalledWith(meetingUuid, callId);
       expect(participant.onBan).toHaveBeenCalledWith(true);
     });
-
     it('should call the api with a delay', async () => {
       const number = '1234';
       const meetingUuid = 'some-meeting-uuid';
       const callId = 'some-call-id';
       const someDelay = 2;
+      // @ts-expect-error
       const room = new Room();
       room.setMeetingUuid(meetingUuid);
-
       const banMeetingParticipant = jest.fn();
-
+      // @ts-expect-error
       getApiClient.mockImplementation(() => ({
         calld: {
           banMeetingParticipant,
         },
       }));
-
       const participant = new Wazo.RemoteParticipant(room, {
         call_id: callId,
         caller_id_name: 'Alice',
         caller_id_number: number,
+        user_uuid: 'some_uuid',
       });
-
       participant.delay = jest.fn();
       participant.onBan = jest.fn();
-
       await participant.ban(someDelay);
       expect(banMeetingParticipant).toHaveBeenCalledWith(meetingUuid, callId);
       expect(participant.delay).toHaveBeenCalledWith(someDelay);

package/src/simple/room/__tests__/{RemoteParticipant.test.js → RemoteParticipant.test.ts}

@@ -4,7 +4,11 @@ import Wazo from '../../index';
 describe('RemoteParticipant', () => {
   it('should fall back on number when name is <unknown>', () => {
     const number = '1234';
-    const participant = new Wazo.RemoteParticipant(null, { caller_id_name: '<unknown>', caller_id_number: number });
+    // @ts-expect-error
+    const participant = new Wazo.RemoteParticipant(null, {
+      caller_id_name: '<unknown>',
+      caller_id_number: number,
+    });
     expect(participant.name).toEqual(number);
   });
 });

package/src/simple/utils.ts

@@ -0,0 +1,12 @@
+/* global navigator */
+import Wazo from './index';
+
+const createLocalStream = async (kind: string, options: Record<string, any> = {}) => {
+  const createOptions: Record<string, any> = {};
+  createOptions[kind] = Object.keys(options).length > 0 ? options : true;
+  const mediaStream = await navigator.mediaDevices.getUserMedia(createOptions);
+  return new Wazo.Stream(mediaStream, new Wazo.LocalParticipant(null, { call_id: 'some-call-id', caller_id_name: 'some-call-id-name' }));
+};
+
+export const createLocalVideoStream = async (options: Record<string, any>) => createLocalStream('video', options);
+export const createLocalAudioStream = async (options: Record<string, any>) => createLocalStream('audio', options);

package/src/types/WebSocketMessage.ts

@@ -0,0 +1,335 @@
+import type { SwitchboardCallItems, SwitchboardAnwseredQueuedCall, SwitchboardAnwseredHeldCall } from '../domain/SwitchboardCall';
+import type { ChatMessageResponse } from '../domain/ChatMessage';
+import ChatRoom from '../domain/ChatRoom';
+import Meeting from '../domain/Meeting';
+import type MeetingAuthorization from '../domain/MeetingAuthorization';
+
+type WebSocketBaseMessage = {
+  op: string;
+  origin_uuid: string;
+  required_acl: string;
+};
+
+export type ExternalAuth = {
+  external_auth_name: string;
+  user_uuid: string;
+};
+
+export type CallMessage = {
+  call_id: string;
+  caller_id_number: string;
+  creation_time: string;
+  dialed_extension: string;
+  on_hold: boolean;
+  peer_caller_id_name: string;
+  peer_caller_id_number: string;
+  status: string;
+};
+
+export type CallEventMessage = {
+  call_id: string;
+  user_uuid: string;
+};
+
+export type ChatMessageEvent = {
+  from: string[];
+  msg: string;
+  to: string[];
+};
+
+export type FavoriteEvent = {
+  source: string;
+  source_entry_id: string;
+  user_uuid: string;
+  xivo_uuid: string;
+};
+
+export type VoicemailDataEvent = {
+  caller_id_name: string;
+  caller_id_num: string;
+  duration: number;
+  folder: {
+    name: string;
+    type: string;
+  };
+  id: string;
+  timestamp: number;
+};
+
+export type VoicemailEvent = {
+  message: VoicemailDataEvent;
+  message_id: string;
+  user_uuid: string;
+  voicemail_id: number;
+};
+
+export type CallLogEvent = {
+  answer: string;
+  answered: boolean;
+  call_direction: string;
+  destination_extension: string;
+  destination_internal_context: any | null | undefined;
+  destination_internal_extension: any | null | undefined;
+  destination_line_id: any | null | undefined;
+  destination_name: string;
+  destination_user_uuid: any | null | undefined;
+  duration: number;
+  end: string;
+  id: number;
+  requested_context: string;
+  requested_extension: string;
+  requested_internal_context: any | null | undefined;
+  requested_internal_extension: any | null | undefined;
+  source_extension: string;
+  source_internal_context: string;
+  source_internal_extension: string;
+  source_line_id: number;
+  source_name: string;
+  source_user_uuid: string;
+  start: string;
+};
+
+export type UserStatusUpdateEvent = {
+  status: string;
+  user_uuid: string;
+};
+
+export type DoNotDisturbUpdateEvent = {
+  enabled: boolean;
+  user_uuid: string;
+};
+
+export type EndpointStatusUpdateEvent = {
+  endpoint_id: string;
+  status: string;
+};
+
+export type PresencesReadEvent = {
+  lines: Array<{
+    id: number;
+    state: string;
+  }>;
+  sessions: Array<any>;
+  state: string;
+  status: string;
+  tenant_uuid: string;
+  uuid: string;
+};
+
+export type RoomParticipantUpdate = {
+  admin: boolean;
+  call_id: string;
+  caller_id_name: string;
+  caller_id_number: string;
+  conference_id: number;
+  id: string;
+  language: string;
+  muted: boolean;
+  user_uuid: string;
+};
+
+export type MeetingParticipantUpdate = {
+  admin: boolean;
+  call_id: string;
+  caller_id_name: string;
+  caller_id_number: string;
+  room_uuid: string;
+  id: string;
+  language: string;
+  muted: boolean;
+  user_uuid: string;
+};
+
+export type FaxOutboundFailedEvent = {
+  call_id: string;
+  caller_id: string;
+  context: string;
+  error: string;
+  extension: string;
+  id: string;
+  tenant_uuid: string;
+  user_uuid: string;
+};
+
+export type FaxOutboundSucceededEvent = {
+  call_id: string;
+  caller_id: string;
+  context: string;
+  error: string;
+  extension: string;
+  id: string;
+  tenant_uuid: string;
+  user_uuid: string;
+};
+
+export type AgentStatusUpdateEvent = {
+  agent_id: string;
+  status: string;
+};
+
+type CallCreated = WebSocketBaseMessage & {
+  data: CallMessage;
+  name: 'call_created';
+};
+
+type CallUpdated = WebSocketBaseMessage & {
+  data: CallMessage;
+  name: 'call_updated';
+};
+
+type CallEnded = WebSocketBaseMessage & {
+  data: CallMessage;
+  name: 'call_ended';
+};
+
+type CallHeld = WebSocketBaseMessage & {
+  data: CallEventMessage;
+  name: 'call_held';
+};
+
+type CallResumed = WebSocketBaseMessage & {
+  data: CallEventMessage;
+  name: 'call_resumed';
+};
+
+type ChatMessageSent = WebSocketBaseMessage & {
+  data: ChatMessageEvent;
+  name: 'chatd_user_room_created';
+};
+
+type ChatRoomCreate = WebSocketBaseMessage & {
+  data: ChatRoom;
+  name: 'chatd_user_room_message_created';
+};
+
+type VoicemailCreated = WebSocketBaseMessage & {
+  data: VoicemailEvent;
+  name: 'user_voicemail_message_created';
+};
+
+type UpdateDoNotDisturb = WebSocketBaseMessage & {
+  data: DoNotDisturbUpdateEvent;
+  name: 'users_services_dnd_updated';
+};
+
+type VoicemailDeleted = WebSocketBaseMessage & {
+  data: VoicemailEvent;
+  name: 'user_voicemail_message_deleted';
+};
+
+type FavoriteAdded = WebSocketBaseMessage & {
+  data: FavoriteEvent;
+  name: 'favorite_added';
+};
+
+type FavoriteDeleted = WebSocketBaseMessage & {
+  data: FavoriteEvent;
+  name: 'favorite_deleted';
+};
+
+type NewCallLog = WebSocketBaseMessage & {
+  data: CallLogEvent;
+  name: 'call_log_user_created';
+};
+
+type UserStatusUpdate = WebSocketBaseMessage & {
+  data: UserStatusUpdateEvent;
+  name: 'user_status_update';
+};
+
+type EndpointStatusUpdate = WebSocketBaseMessage & {
+  data: EndpointStatusUpdateEvent;
+  name: 'endpoint_status_update';
+};
+
+type ExternalAuthAdded = WebSocketBaseMessage & {
+  data: ExternalAuth;
+  name: 'auth_user_external_auth_added';
+};
+
+type ExternalAuthDeleted = WebSocketBaseMessage & {
+  data: ExternalAuth;
+  name: 'auth_user_external_auth_deleted';
+};
+
+type PresencesRead = WebSocketBaseMessage & {
+  data: PresencesReadEvent;
+  name: 'chatd_presence_updated';
+};
+
+type ParticipantJoinedRoom = WebSocketBaseMessage & {
+  data: RoomParticipantUpdate;
+  name: 'conference_user_participant_joined';
+};
+
+type ParticipantLeftRoom = WebSocketBaseMessage & {
+  data: RoomParticipantUpdate;
+  name: 'conference_user_participant_left';
+};
+
+type ParticipantJoinedMeeting = WebSocketBaseMessage & {
+  data: MeetingParticipantUpdate;
+  name: 'meeting_user_participant_joined';
+};
+
+type ParticipantLeftMeeting = WebSocketBaseMessage & {
+  data: MeetingParticipantUpdate;
+  name: 'meeting_user_participant_left';
+};
+
+type SwitchboardQueuedCallsUpdated = WebSocketBaseMessage & {
+  data: SwitchboardCallItems;
+  name: 'switchboard_queued_calls_updated';
+};
+
+type SwitchboardQueuedCallAnswered = WebSocketBaseMessage & {
+  data: SwitchboardAnwseredQueuedCall;
+  name: 'switchboard_queued_call_answered';
+};
+
+type SwitchboardHeldCallsUpdated = WebSocketBaseMessage & {
+  data: any;
+  name: 'switchboard_held_calls_updated';
+};
+
+type SwitchboardHeldCallAnswered = WebSocketBaseMessage & {
+  data: SwitchboardAnwseredHeldCall;
+  name: 'switchboard_held_call_answered';
+};
+
+type FaxOutboundFailed = WebSocketBaseMessage & {
+  data: FaxOutboundFailedEvent;
+  name: 'fax_outbound_user_failed';
+};
+
+type FaxOutboundSucceeded = WebSocketBaseMessage & {
+  data: FaxOutboundSucceededEvent;
+  name: 'fax_outbound_user_succeeded';
+};
+
+type AgentStatusUpdate = WebSocketBaseMessage & {
+  data: AgentStatusUpdateEvent;
+  name: 'agent_status_update';
+};
+
+type AgentPaused = WebSocketBaseMessage & {
+  data: any;
+  name: 'agent_paused';
+};
+
+type AgentUnpaused = WebSocketBaseMessage & {
+  data: any;
+  name: 'agent_unpaused';
+};
+
+type MeetingUserProgress = WebSocketBaseMessage & {
+  data: Meeting;
+  name: 'meeting_user_progress';
+};
+
+type MeetingAuthorizationPending = WebSocketBaseMessage & {
+  data: MeetingAuthorization;
+  name: 'meeting_authorization_pending';
+};
+
+export type WebSocketMessage = CallCreated | CallUpdated | CallEnded | CallHeld | CallResumed | NewCallLog | ChatMessageSent | (WebSocketBaseMessage & ChatMessageResponse) | ChatRoomCreate | VoicemailCreated | UpdateDoNotDisturb | VoicemailDeleted | FavoriteAdded | FavoriteDeleted | UserStatusUpdate | EndpointStatusUpdate | ExternalAuthAdded | ExternalAuthDeleted | PresencesRead | SwitchboardQueuedCallsUpdated | SwitchboardQueuedCallAnswered | SwitchboardHeldCallsUpdated | SwitchboardHeldCallAnswered | ParticipantJoinedRoom | ParticipantLeftRoom | ParticipantJoinedMeeting | ParticipantLeftMeeting | FaxOutboundFailed | FaxOutboundSucceeded | AgentStatusUpdate | AgentPaused | AgentUnpaused | MeetingUserProgress | MeetingAuthorizationPending;

package/src/types/global.d.ts

@@ -0,0 +1,26 @@
+/* eslint-disable vars-on-top */
+/* eslint-disable no-var */
+
+declare global {
+  var Wazo;
+  var wazoClients;
+  var wazoClientId;
+  var wazoClientToken;
+  var wazoRefreshToken;
+  var wazoRefreshTenantId;
+  var wazoRefreshDomainName;
+  var wazoOnRefreshToken;
+  var wazoOnRefreshTokenError;
+  var wazoRefreshExpiration;
+  var wazoRefreshBackend;
+  var wazoIsMobile;
+  var wazoFetchOptions;
+  var wazoCurrentServer;
+  var wazoAuthInstance;
+  var wazoConfigurationInstance;
+  var wazoDirectoryInstance;
+  var wazoTelephonyInstance;
+  var wazoWebsocketInstance;
+}
+
+export {};