@signalwire/js 1.3.0-dev.1 → 1.4.0

package/dist/esm/common/src/webrtc/Call.d.ts

@@ -1,11 +1,11 @@
-import WebRTCCall from './WebRTCCall';
+import BaseCall from './BaseCall';
 import { CallOptions } from './interfaces';
-export default class Call extends WebRTCCall {
+export default class Call extends BaseCall {
+    screenShare: Call;
     private _statsInterval;
-    startScreenShare(opts?: CallOptions): Promise<WebRTCCall>;
+    hangup(params?: any, execute?: boolean): void;
+    startScreenShare(opts?: CallOptions): Promise<Call>;
     stopScreenShare(): void;
-    addSecondSource(opts?: CallOptions): Promise<WebRTCCall>;
-    removeSecondSource(): void;
     setAudioOutDevice(deviceId: string): Promise<boolean>;
     protected _finalize(): void;
     private _stats;

package/dist/esm/common/src/webrtc/Call.js

@@ -8,19 +8,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import logger from '../util/logger';
-import WebRTCCall from './WebRTCCall';
+import BaseCall from './BaseCall';
 import { getDisplayMedia, setMediaElementSinkId } from '../util/webrtc';
-import { Notification } from './constants';
-export default class Call extends WebRTCCall {
+export default class Call extends BaseCall {
     constructor() {
         super(...arguments);
         this._statsInterval = null;
     }
+    hangup(params = {}, execute = true) {
+        if (this.screenShare instanceof Call) {
+            this.screenShare.hangup(params, execute);
+        }
+        super.hangup(params, execute);
+    }
     startScreenShare(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { audio = false, video = true } = (opts || {});
-            const displayStream = yield getDisplayMedia({ audio, video });
-            displayStream.getVideoTracks().forEach(t => {
+            const displayStream = yield getDisplayMedia({ video: true });
+            displayStream.getTracks().forEach(t => {
                 t.addEventListener('ended', () => {
                     if (this.screenShare) {
                         this.screenShare.hangup();
@@ -28,8 +32,7 @@ export default class Call extends WebRTCCall {
                 });
             });
             const { remoteCallerName, remoteCallerNumber, callerName, callerNumber } = this.options;
-            const options = Object.assign({ screenShare: true, recoverCall: false, skipLiveArray: true, skipNotifications: true, localStream: displayStream, destinationNumber: this.extension, remoteCallerName,
-                remoteCallerNumber, callerName: `${callerName} (Screen)`, callerNumber: `${callerNumber} (Screen)` }, opts);
+            const options = Object.assign({ screenShare: true, localStream: displayStream, destinationNumber: `${this.extension}-screen`, remoteCallerName, remoteCallerNumber: `${remoteCallerNumber}-screen`, callerName: `${callerName} (Screen)`, callerNumber: `${callerNumber} (Screen)` }, opts);
             this.screenShare = new Call(this.session, options);
             this.screenShare.invite();
             return this.screenShare;
@@ -40,36 +43,14 @@ export default class Call extends WebRTCCall {
             this.screenShare.hangup();
         }
     }
-    addSecondSource(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { remoteCallerName, remoteCallerNumber, callerName, callerNumber } = this.options;
-            const options = Object.assign({ secondSource: true, recoverCall: false, skipLiveArray: true, skipNotifications: true, destinationNumber: this.extension, remoteCallerName,
-                remoteCallerNumber, callerName: `${callerName} (Second Source)`, callerNumber: `${callerNumber} (Second Source)`, localStream: null }, opts);
-            this.secondSource = new Call(this.session, options);
-            this.secondSource.invite();
-            return this.secondSource;
-        });
-    }
-    removeSecondSource() {
-        if (this.secondSource instanceof Call) {
-            this.secondSource.hangup();
-        }
-    }
     setAudioOutDevice(deviceId) {
         return __awaiter(this, void 0, void 0, function* () {
             this.options.speakerId = deviceId;
-            const { remoteElement, speakerId, experimental } = this.options;
-            if (experimental === true) {
-                try {
-                    yield this.audioElements[0].setSinkId(speakerId);
-                    this._dispatchNotification({ type: Notification.DeviceUpdated });
-                }
-                catch (error) {
-                    console.error('setAudioOutDevice error', this.audioElements, speakerId);
-                }
-                return;
+            const { remoteElement, speakerId } = this.options;
+            if (remoteElement && speakerId) {
+                return setMediaElementSinkId(remoteElement, speakerId);
             }
-            return setMediaElementSinkId(remoteElement, speakerId);
+            return false;
         });
     }
     _finalize() {

package/dist/esm/common/src/webrtc/CantinaAuth.d.ts

@@ -1,17 +1,22 @@
-import { ICantinaUser } from './interfaces';
-declare type BootstrapResponse = {
-    project_id: string;
-};
-declare type RefreshResponse = {
+import { ICantinaAuthParams, ICantinaUser } from './interfaces';
+type RefreshResponse = {
+    project: string;
     jwt_token: string;
 };
+type CheckInviteTokenResponse = {
+    valid: boolean;
+    name: string;
+    config: object;
+};
 declare class CantinaAuth {
+    private params;
     baseUrl: string;
     hostname: string;
+    constructor(params?: ICantinaAuthParams);
     private _fetch;
-    bootstrap(hostname: string): Promise<BootstrapResponse>;
-    login(username: string, project_id: string): Promise<ICantinaUser>;
-    refresh(refreshToken?: any): Promise<RefreshResponse>;
-    logout(): Promise<void>;
+    userLogin(username: string, password: string): Promise<ICantinaUser>;
+    guestLogin(name: string, email: string, token: string): Promise<ICantinaUser>;
+    refresh(): Promise<RefreshResponse>;
+    checkInviteToken(token: string): Promise<CheckInviteTokenResponse>;
 }
 export default CantinaAuth;

package/dist/esm/common/src/webrtc/CantinaAuth.js

@@ -16,57 +16,51 @@ const FETCH_OPTIONS = {
     }
 };
 class CantinaAuth {
-    constructor() {
-        this.baseUrl = '';
+    constructor(params = {}) {
+        this.params = params;
+        this.baseUrl = 'https://cantina-backend.signalwire.com';
         this._fetch = (url, options) => {
             return fetch(url, options).then((response) => __awaiter(this, void 0, void 0, function* () {
+                const payload = yield response.json();
                 if (response.status >= 200 && response.status < 300) {
-                    if (response.status === 204) {
-                        return response;
-                    }
-                    const payload = yield response.json();
                     return payload;
                 }
                 else {
                     const errorMessage = `HTTP Request failed with status ${response.status}`;
                     const error = new Error(errorMessage);
-                    error.response = response;
+                    error.payload = payload;
                     return Promise.reject(error);
                 }
             }));
         };
+        const { hostname = location.hostname } = params;
+        this.hostname = hostname;
     }
-    bootstrap(hostname) {
+    userLogin(username, password) {
         return __awaiter(this, void 0, void 0, function* () {
-            const clear = encodeURIComponent(hostname);
-            const url = `${this.baseUrl}/api/configuration?hostname=${clear}`;
-            const response = yield this._fetch(url, Object.assign(Object.assign({}, FETCH_OPTIONS), { method: 'GET' }));
-            logger.info('bootstrap response', response);
+            const response = yield this._fetch(`${this.baseUrl}/login/user`, Object.assign(Object.assign({}, FETCH_OPTIONS), { body: JSON.stringify({ username, password, hostname: this.hostname }) }));
+            logger.info('userLogin response', response);
             return response;
         });
     }
-    login(username, project_id) {
+    guestLogin(name, email, token) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this._fetch(`${this.baseUrl}/api/login`, Object.assign(Object.assign({}, FETCH_OPTIONS), { body: JSON.stringify({ username, project_id }) }));
-            logger.info('userLogin response', response);
+            const response = yield this._fetch(`${this.baseUrl}/login/guest`, Object.assign(Object.assign({}, FETCH_OPTIONS), { body: JSON.stringify({ name, email, token, hostname: this.hostname }) }));
+            logger.info('guestLogin response', response);
             return response;
         });
     }
-    refresh(refreshToken = null) {
+    refresh() {
         return __awaiter(this, void 0, void 0, function* () {
-            const options = Object.assign(Object.assign({}, FETCH_OPTIONS), { method: 'PUT' });
-            if (refreshToken) {
-                options.body = JSON.stringify({ refresh_token: refreshToken });
-            }
-            const response = yield this._fetch(`${this.baseUrl}/api/refresh`, options);
+            const response = yield this._fetch(`${this.baseUrl}/refresh`, Object.assign(Object.assign({}, FETCH_OPTIONS), { method: 'PUT', body: JSON.stringify({ hostname: this.hostname }) }));
             logger.info('refresh response', response);
             return response;
         });
     }
-    logout() {
+    checkInviteToken(token) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this._fetch(`${this.baseUrl}/api/logout`, Object.assign(Object.assign({}, FETCH_OPTIONS), { method: 'PUT' }));
-            logger.info('logout response', response);
+            const response = yield this._fetch(`${this.baseUrl}/check-token`, Object.assign(Object.assign({}, FETCH_OPTIONS), { body: JSON.stringify({ token, hostname: this.hostname }) }));
+            logger.info('checkInviteToken response', response);
             return response;
         });
     }

package/dist/esm/common/src/webrtc/LayoutHandler.d.ts

@@ -0,0 +1,3 @@
+import BrowserSession from '../BrowserSession';
+declare const MCULayoutEventHandler: (session: BrowserSession, eventData: any) => void;
+export { MCULayoutEventHandler };

package/dist/esm/common/src/webrtc/LayoutHandler.js

@@ -0,0 +1,36 @@
+import { NOTIFICATION_TYPE, ConferenceAction } from './constants';
+import { SwEvent } from '../util/constants';
+import { trigger } from '../services/Handler';
+import { safeParseJson } from '../util/helpers';
+const MCULayoutEventHandler = (session, eventData) => {
+    const { contentType, canvasType, callID, canvasInfo = null, currentLayerIdx = -1 } = eventData;
+    if (canvasInfo && canvasType !== 'mcu-personal-canvas') {
+        delete canvasInfo.memberID;
+    }
+    const data = {
+        type: NOTIFICATION_TYPE.conferenceUpdate,
+        call: session.calls[callID],
+        canvasInfo: _clearCanvasInfo(canvasInfo),
+        currentLayerIdx
+    };
+    switch (contentType) {
+        case 'layer-info': {
+            const notification = Object.assign({ action: ConferenceAction.LayerInfo }, data);
+            trigger(SwEvent.Notification, notification, session.uuid);
+            break;
+        }
+        case 'layout-info': {
+            const notification = Object.assign({ action: ConferenceAction.LayoutInfo }, data);
+            trigger(SwEvent.Notification, notification, session.uuid);
+            break;
+        }
+    }
+};
+const _clearCanvasInfo = (canvasInfo) => {
+    const tmp = JSON.stringify(canvasInfo)
+        .replace(/memberID/g, 'participantId')
+        .replace(/ID"/g, 'Id"')
+        .replace(/POS"/g, 'Pos"');
+    return safeParseJson(tmp);
+};
+export { MCULayoutEventHandler };

package/dist/esm/common/src/webrtc/Peer.d.ts

@@ -0,0 +1,23 @@
+import { PeerType } from './constants';
+import { CallOptions } from './interfaces';
+export default class Peer {
+    type: PeerType;
+    private options;
+    instance: RTCPeerConnection;
+    onSdpReadyTwice: Function;
+    private _constraints;
+    private _negotiating;
+    constructor(type: PeerType, options: CallOptions);
+    startNegotiation(): void;
+    private _init;
+    private _createOffer;
+    private _createAnswer;
+    private _setLocalDescription;
+    private _sdpReady;
+    private _retrieveLocalStream;
+    private _isOffer;
+    private _isAnswer;
+    private _config;
+    private _getSenderByKind;
+    applyMediaConstraints(kind: string, constraints: MediaTrackConstraints): Promise<void>;
+}

package/dist/esm/common/src/webrtc/Peer.js

@@ -0,0 +1,169 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import logger from '../util/logger';
+import { getUserMedia, getMediaConstraints, sdpStereoHack, sdpBitrateHack } from './helpers';
+import { SwEvent } from '../util/constants';
+import { PeerType } from './constants';
+import { attachMediaStream, muteMediaElement, sdpToJsonHack, RTCPeerConnection, streamIsValid } from '../util/webrtc';
+import { isFunction } from '../util/helpers';
+import { trigger } from '../services/Handler';
+import { filterIceServers } from './helpers';
+export default class Peer {
+    constructor(type, options) {
+        this.type = type;
+        this.options = options;
+        this.onSdpReadyTwice = null;
+        this._negotiating = false;
+        logger.info('New Peer with type:', this.type, 'Options:', this.options);
+        this._constraints = { offerToReceiveAudio: true, offerToReceiveVideo: true };
+        this._sdpReady = this._sdpReady.bind(this);
+        this._init();
+    }
+    startNegotiation() {
+        this._negotiating = true;
+        if (this._isOffer()) {
+            this._createOffer();
+        }
+        else {
+            this._createAnswer();
+        }
+    }
+    _init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.instance = RTCPeerConnection(this._config());
+            this.instance.onsignalingstatechange = event => {
+                switch (this.instance.signalingState) {
+                    case 'stable':
+                        this._negotiating = false;
+                        break;
+                    case 'closed':
+                        this.instance = null;
+                        break;
+                    default:
+                        this._negotiating = true;
+                }
+            };
+            this.instance.onnegotiationneeded = event => {
+                if (this._negotiating) {
+                    logger.debug('Skip twice onnegotiationneeded..');
+                    return;
+                }
+                this.startNegotiation();
+            };
+            this.options.localStream = yield this._retrieveLocalStream()
+                .catch(error => {
+                trigger(SwEvent.MediaError, error, this.options.id);
+                return null;
+            });
+            const { localElement, localStream = null, screenShare = false } = this.options;
+            if (streamIsValid(localStream)) {
+                if (typeof this.instance.addTrack === 'function') {
+                    localStream.getTracks().forEach(t => this.instance.addTrack(t, localStream));
+                }
+                else {
+                    this.instance.addStream(localStream);
+                }
+                if (screenShare !== true) {
+                    muteMediaElement(localElement);
+                    attachMediaStream(localElement, localStream);
+                }
+            }
+            else if (localStream === null) {
+                this.startNegotiation();
+            }
+        });
+    }
+    _createOffer() {
+        if (!this._isOffer()) {
+            return;
+        }
+        this.instance.createOffer(this._constraints)
+            .then(this._setLocalDescription.bind(this))
+            .then(this._sdpReady)
+            .catch(error => logger.error('Peer _createOffer error:', error));
+    }
+    _createAnswer() {
+        if (!this._isAnswer()) {
+            return;
+        }
+        const { remoteSdp, useStereo } = this.options;
+        const sdp = useStereo ? sdpStereoHack(remoteSdp) : remoteSdp;
+        const sessionDescr = sdpToJsonHack({ sdp, type: PeerType.Offer });
+        this.instance.setRemoteDescription(sessionDescr)
+            .then(() => this.instance.createAnswer())
+            .then(this._setLocalDescription.bind(this))
+            .then(this._sdpReady)
+            .catch(error => logger.error('Peer _createAnswer error:', error));
+    }
+    _setLocalDescription(sessionDescription) {
+        const { useStereo, googleMaxBitrate, googleMinBitrate, googleStartBitrate } = this.options;
+        if (useStereo) {
+            sessionDescription.sdp = sdpStereoHack(sessionDescription.sdp);
+        }
+        if (googleMaxBitrate && googleMinBitrate && googleStartBitrate) {
+            sessionDescription.sdp = sdpBitrateHack(sessionDescription.sdp, googleMaxBitrate, googleMinBitrate, googleStartBitrate);
+        }
+        return this.instance.setLocalDescription(sessionDescription);
+    }
+    _sdpReady() {
+        if (isFunction(this.onSdpReadyTwice)) {
+            this.onSdpReadyTwice(this.instance.localDescription);
+        }
+    }
+    _retrieveLocalStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (streamIsValid(this.options.localStream)) {
+                return this.options.localStream;
+            }
+            const constraints = yield getMediaConstraints(this.options);
+            return getUserMedia(constraints);
+        });
+    }
+    _isOffer() {
+        return this.type === PeerType.Offer;
+    }
+    _isAnswer() {
+        return this.type === PeerType.Answer;
+    }
+    _config() {
+        const { iceServers = [], iceTransportPolicy = 'all', disableUdpIceServers = false } = this.options;
+        const filteredIceServers = filterIceServers(iceServers, { disableUdpIceServers });
+        const config = {
+            iceTransportPolicy,
+            sdpSemantics: 'unified-plan',
+            bundlePolicy: 'max-compat',
+            iceServers: filteredIceServers,
+        };
+        logger.info('RTC config', config);
+        return config;
+    }
+    _getSenderByKind(kind) {
+        if (this.instance) {
+            return this.instance.getSenders().find(({ track }) => (track && track.kind === kind));
+        }
+    }
+    applyMediaConstraints(kind, constraints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const sender = this._getSenderByKind(kind);
+                if (!sender || !sender.track) {
+                    return logger.info('No sender to apply constraints', kind, constraints);
+                }
+                if (sender.track.readyState === 'live') {
+                    logger.info(`Apply ${kind} constraints`, this.options.id, constraints);
+                    yield sender.track.applyConstraints(constraints);
+                }
+            }
+            catch (error) {
+                logger.error('Error applying constraints', kind, constraints);
+            }
+        });
+    }
+}

package/dist/esm/common/src/webrtc/VertoHandler.d.ts

@@ -1,3 +1,12 @@
 import BrowserSession from '../BrowserSession';
-declare const _default: (session: BrowserSession, msg: any) => any;
-export default _default;
+declare class VertoHandler {
+    session: BrowserSession;
+    nodeId: string;
+    constructor(session: BrowserSession);
+    private _ack;
+    handleMessage(msg: any): Promise<void>;
+    private _retrieveCallId;
+    private _handlePvtEvent;
+    private _handleSessionEvent;
+}
+export default VertoHandler;