@signalwire/js 1.3.0-dev.1 → 1.3.0

package/dist/esm/common/src/services/Handler.js

@@ -1,81 +1,78 @@
-import { isFunction } from '../util/helpers';
+import { objEmpty, isFunction } from '../util/helpers';
 const GLOBAL = 'GLOBAL';
 const queue = {};
-const _buildEventName = (event, uniqueId) => `${event}|${uniqueId}`;
-const isQueued = (event, uniqueId = GLOBAL) => {
-    const eventName = _buildEventName(event, uniqueId);
-    return eventName in queue;
-};
-const queueLength = (event, uniqueId = GLOBAL) => {
-    const eventName = _buildEventName(event, uniqueId);
-    return eventName in queue ? queue[eventName].length : 0;
+const isQueued = (eventName, uniqueId = GLOBAL) => queue.hasOwnProperty(eventName) && queue[eventName].hasOwnProperty(uniqueId);
+const queueLength = (eventName, uniqueId = GLOBAL) => {
+    if (!isQueued(eventName, uniqueId)) {
+        return 0;
+    }
+    return queue[eventName][uniqueId].length;
 };
-const register = (event, callback, uniqueId = GLOBAL) => {
-    const eventName = _buildEventName(event, uniqueId);
-    if (!(eventName in queue)) {
-        queue[eventName] = [];
+const register = (eventName, callback, uniqueId = GLOBAL) => {
+    if (!queue.hasOwnProperty(eventName)) {
+        queue[eventName] = {};
     }
-    queue[eventName].push(callback);
+    if (!queue[eventName].hasOwnProperty(uniqueId)) {
+        queue[eventName][uniqueId] = [];
+    }
+    queue[eventName][uniqueId].push(callback);
 };
-const registerOnce = (event, callback, uniqueId = GLOBAL) => {
+const registerOnce = (eventName, callback, uniqueId = GLOBAL) => {
     const cb = function (data) {
-        deRegister(event, cb, uniqueId);
+        deRegister(eventName, cb, uniqueId);
         callback(data);
     };
     cb.prototype.targetRef = callback;
-    return register(event, cb, uniqueId);
+    return register(eventName, cb, uniqueId);
 };
-const deRegister = (event, callback, uniqueId = GLOBAL) => {
-    if (!isQueued(event, uniqueId)) {
+const deRegister = (eventName, callback, uniqueId = GLOBAL) => {
+    if (!isQueued(eventName, uniqueId)) {
         return false;
     }
-    const eventName = _buildEventName(event, uniqueId);
     if (isFunction(callback)) {
-        const len = queue[eventName].length;
+        const len = queue[eventName][uniqueId].length;
         for (let i = len - 1; i >= 0; i--) {
-            const fn = queue[eventName][i];
+            const fn = queue[eventName][uniqueId][i];
             if (callback === fn || (fn.prototype && callback === fn.prototype.targetRef)) {
-                queue[eventName].splice(i, 1);
+                queue[eventName][uniqueId].splice(i, 1);
             }
         }
     }
     else {
-        queue[eventName] = [];
+        queue[eventName][uniqueId] = [];
     }
-    if (queue[eventName].length === 0) {
-        delete queue[eventName];
+    if (queue[eventName][uniqueId].length === 0) {
+        delete queue[eventName][uniqueId];
+        if (objEmpty(queue[eventName])) {
+            delete queue[eventName];
+        }
     }
     return true;
 };
-const trigger = (event, data, uniqueId = GLOBAL, globalPropagation = true) => {
+const trigger = (eventName, data, uniqueId = GLOBAL, globalPropagation = true) => {
     const _propagate = globalPropagation && uniqueId !== GLOBAL;
-    if (!isQueued(event, uniqueId)) {
+    if (!isQueued(eventName, uniqueId)) {
         if (_propagate) {
-            trigger(event, data);
+            trigger(eventName, data);
         }
         return false;
     }
-    const eventName = _buildEventName(event, uniqueId);
-    const len = queue[eventName].length;
+    const len = queue[eventName][uniqueId].length;
     if (!len) {
         if (_propagate) {
-            trigger(event, data);
+            trigger(eventName, data);
         }
         return false;
     }
     for (let i = len - 1; i >= 0; i--) {
-        queue[eventName][i](data);
+        queue[eventName][uniqueId][i](data);
     }
     if (_propagate) {
-        trigger(event, data);
+        trigger(eventName, data);
     }
     return true;
 };
-const deRegisterAll = (event) => {
-    const eventName = _buildEventName(event, '');
-    Object.keys(queue)
-        .filter(name => name.indexOf(eventName) === 0)
-        .forEach(event => delete queue[event]);
+const deRegisterAll = (eventName) => {
+    delete queue[eventName];
 };
-const clearQueue = () => Object.keys(queue).forEach(event => delete queue[event]);
-export { trigger, register, registerOnce, deRegister, deRegisterAll, isQueued, queueLength, clearQueue };
+export { trigger, register, registerOnce, deRegister, deRegisterAll, isQueued, queueLength };

package/dist/esm/common/src/util/constants/index.d.ts

@@ -2,7 +2,6 @@ export declare const STORAGE_PREFIX = "@signalwire:";
 export declare const ADD = "add";
 export declare const REMOVE = "remove";
 export declare const SESSION_ID = "sessId";
-export declare const VERTO_PROTOCOL = "verto-protocol";
 export declare enum SwEvent {
     SocketOpen = "signalwire.socket.open",
     SocketClose = "signalwire.socket.close",

package/dist/esm/common/src/util/constants/index.js

@@ -2,7 +2,6 @@ export const STORAGE_PREFIX = '@signalwire:';
 export const ADD = 'add';
 export const REMOVE = 'remove';
 export const SESSION_ID = 'sessId';
-export const VERTO_PROTOCOL = 'verto-protocol';
 export var SwEvent;
 (function (SwEvent) {
     SwEvent["SocketOpen"] = "signalwire.socket.open";

package/dist/esm/common/src/util/helpers.d.ts

@@ -1,8 +1,16 @@
 export declare const deepCopy: (obj: Object) => any;
 export declare const objEmpty: (obj: Object) => boolean;
 export declare const mutateStorageKey: (key: string) => string;
-export declare const mutateLiveArrayData: (data: any[]) => any;
+export declare const mutateLiveArrayData: (data: any) => {
+    participantId: number;
+    participantNumber: any;
+    participantName: any;
+    codec: any;
+    media: {};
+    participantData: any;
+};
 export declare const safeParseJson: (value: string) => string | Object;
+export declare const isDefined: (variable: any) => boolean;
 export declare const isFunction: (variable: any) => boolean;
 export declare const findElementByType: (tag: string | Function | HTMLMediaElement) => HTMLMediaElement;
 export declare const checkWebSocketHost: (host: string) => string;
@@ -10,4 +18,3 @@ export declare const destructResponse: (response: any, nodeId?: string) => {
     [key: string]: any;
 };
 export declare const randomInt: (min: number, max: number) => number;
-export declare const roundToFixed: (value: number, num?: number) => number;

package/dist/esm/common/src/util/helpers.js

@@ -1,11 +1,18 @@
+import logger from './logger';
 import { STORAGE_PREFIX } from './constants';
 export const deepCopy = (obj) => JSON.parse(JSON.stringify(obj));
 export const objEmpty = (obj) => Object.keys(obj).length === 0;
 export const mutateStorageKey = (key) => `${STORAGE_PREFIX}${key}`;
 export const mutateLiveArrayData = (data) => {
-    const [options, memberData, visibility] = data;
-    const { memberID: participantId, callerIDNumber: participantNumber, callerIDName: participantName, company: participantCompany } = memberData;
-    return Object.assign({ participantId, participantNumber, participantName, participantCompany, visibility }, options);
+    const [participantId, participantNumber, participantName, codec, mediaJson, participantData] = data;
+    let media = {};
+    try {
+        media = JSON.parse(mediaJson.replace(/ID"/g, 'Id"'));
+    }
+    catch (error) {
+        logger.warn('Verto LA invalid media JSON string:', mediaJson);
+    }
+    return { participantId: Number(participantId), participantNumber, participantName, codec, media, participantData };
 };
 export const safeParseJson = (value) => {
     if (typeof value !== 'string') {
@@ -18,6 +25,7 @@ export const safeParseJson = (value) => {
         return value;
     }
 };
+export const isDefined = (variable) => typeof variable !== 'undefined';
 export const isFunction = (variable) => variable instanceof Function || typeof variable === 'function';
 export const findElementByType = (tag) => {
     if (typeof document !== 'object' || !('getElementById' in document)) {
@@ -63,6 +71,3 @@ export const destructResponse = (response, nodeId = null) => {
 export const randomInt = (min, max) => {
     return Math.floor(Math.random() * (max - min + 1) + min);
 };
-export const roundToFixed = (value, num = 2) => {
-    return Number(value.toFixed(num));
-};

package/dist/esm/common/src/util/interfaces.d.ts

@@ -7,6 +7,7 @@ declare type TBladeVersion = {
     minor: number;
     revision: number;
 };
+declare type SipCodec = 'PCMU' | 'PCMA' | 'OPUS' | 'G729' | 'G722' | 'VP8' | 'H264';
 export interface ISubscription {
     channel: string;
     protocol: string;
@@ -31,20 +32,16 @@ export interface IBladeConnectRequest extends IMessageBase {
         agent?: string;
     };
 }
-export interface IBladeAuthorization {
-    expires_at: number;
-    signature: string;
-    project: string;
-    scope_id: string;
-    scopes: string[];
-    resource: string;
-}
 export interface IBladeConnectResult extends IMessageBase {
     sessionid: string;
     nodeid: string;
     master_nodeid: string;
     protocols_uncertified: string[];
-    authorization: IBladeAuthorization;
+    authorization: {
+        expires_at: number;
+        signature: string;
+    };
+    ice_servers?: RTCIceServer[];
 }
 export interface IBladeExecuteRequest extends IMessageBase {
     method: string;
@@ -79,12 +76,7 @@ export interface ISignalWireOptions {
     login?: string;
     passwd?: string;
     password?: string;
-    userVariables?: {
-        [key: string]: any;
-    };
-    loginParams?: {
-        [key: string]: any;
-    };
+    userVariables?: Object;
 }
 export interface SubscribeParams {
     channels?: string[];
@@ -182,33 +174,67 @@ export interface ICall {
     sendDigits: Function;
     sendDigitsAsync: Function;
 }
-export interface ICallDevice {
-    type: string;
+export interface CallingPhoneDevice {
+    type: 'phone';
     params: {
         from_number: string;
         to_number: string;
-        timeout: number;
+        timeout?: number;
+    };
+}
+export interface SipHeader {
+    name: string;
+    value: string;
+}
+export interface CallingSipDevice {
+    type: 'sip';
+    params: {
+        from: string;
+        to: string;
+        headers?: SipHeader[];
+        timeout?: number;
+        codecs?: SipCodec[];
+        webrtc_media?: boolean;
+        from_name?: string;
     };
 }
+export declare type ICallDevice = CallingPhoneDevice | CallingSipDevice;
 export interface ICallPeer {
     call_id: string;
     node_id: string;
     device?: ICallDevice;
 }
 export interface ICallOptions {
+    region?: string;
     device?: ICallDevice;
+    devices?: DeepArray<ICallDevice>;
     peer?: ICallPeer;
     node_id?: string;
     call_id?: string;
     call_state?: string;
     context?: string;
 }
-export interface IMakeCallParams {
-    type: string;
+export interface MakePhoneCallParams {
+    type: 'phone';
     from?: string;
     to: string;
     timeout?: number;
 }
+export interface MakeSipCallParams {
+    type: 'sip';
+    from: string;
+    from_name?: string;
+    to: string;
+    timeout?: number;
+    headers?: SipHeader[];
+    codecs?: SipCodec[];
+    webrtc_media?: boolean;
+}
+export interface IDialCallParams {
+    region?: string;
+    devices: DeepArray<IMakeCallParams>;
+}
+export declare type IMakeCallParams = MakePhoneCallParams | MakeSipCallParams;
 export interface StringTMap<T> {
     [key: string]: T;
 }
@@ -395,4 +421,13 @@ export interface IMessageOptions {
     segments: number;
     reason?: string;
 }
+export interface DialPayload {
+    tag: string;
+    devices: DeepArray<ICallDevice>;
+    region?: string;
+}
+export interface ReferParams {
+    to: string;
+    headers?: SipHeader[];
+}
 export {};

package/dist/esm/common/src/util/logger.js

@@ -5,10 +5,7 @@ const originalFactory = logger.methodFactory;
 logger.methodFactory = (methodName, logLevel, loggerName) => {
     const rawMethod = originalFactory(methodName, logLevel, loggerName);
     return function () {
-        const messages = [];
-        if (typeof window === 'undefined') {
-            messages.push(datetime() + ' -');
-        }
+        const messages = [datetime(), '-'];
         for (let i = 0; i < arguments.length; i++) {
             messages.push(arguments[i]);
         }

package/dist/esm/common/src/util/webrtc/index.d.ts

@@ -2,7 +2,6 @@ declare const RTCPeerConnection: (config: RTCConfiguration) => RTCPeerConnection
 declare const getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
 declare const getDisplayMedia: (constraints: MediaStreamConstraints) => any;
 declare const enumerateDevices: () => Promise<MediaDeviceInfo[]>;
-declare const enumerateDevicesByKind: (filterByKind?: string) => Promise<MediaDeviceInfo[]>;
 declare const getSupportedConstraints: () => MediaTrackSupportedConstraints;
 declare const streamIsValid: (stream: MediaStream) => boolean;
 declare const attachMediaStream: (tag: any, stream: MediaStream) => void;
@@ -13,8 +12,4 @@ declare const toggleMuteMediaElement: (tag: any) => void;
 declare const setMediaElementSinkId: (tag: any, deviceId: string) => Promise<boolean>;
 declare const sdpToJsonHack: (sdp: any) => any;
 declare const stopStream: (stream: MediaStream) => void;
-declare const stopTrack: (track: MediaStreamTrack) => void;
-declare const getHostname: () => string;
-declare const buildVideoElementByTrack: (videoTrack: MediaStreamTrack, streamIds?: string[]) => HTMLVideoElement;
-declare const buildAudioElementByTrack: (audioTrack: MediaStreamTrack, streamIds?: string[]) => HTMLAudioElement;
-export { RTCPeerConnection, getUserMedia, getDisplayMedia, enumerateDevices, enumerateDevicesByKind, getSupportedConstraints, streamIsValid, attachMediaStream, detachMediaStream, sdpToJsonHack, stopStream, stopTrack, muteMediaElement, unmuteMediaElement, toggleMuteMediaElement, setMediaElementSinkId, getHostname, buildVideoElementByTrack, buildAudioElementByTrack, };
+export { RTCPeerConnection, getUserMedia, getDisplayMedia, enumerateDevices, getSupportedConstraints, streamIsValid, attachMediaStream, detachMediaStream, sdpToJsonHack, stopStream, muteMediaElement, unmuteMediaElement, toggleMuteMediaElement, setMediaElementSinkId };

package/dist/esm/common/src/util/webrtc/index.js

@@ -8,18 +8,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { findElementByType } from '../helpers';
-import logger from '../logger';
 const RTCPeerConnection = (config) => new window.RTCPeerConnection(config);
 const getUserMedia = (constraints) => navigator.mediaDevices.getUserMedia(constraints);
 const getDisplayMedia = (constraints) => navigator.mediaDevices.getDisplayMedia(constraints);
 const enumerateDevices = () => navigator.mediaDevices.enumerateDevices();
-const enumerateDevicesByKind = (filterByKind = null) => __awaiter(void 0, void 0, void 0, function* () {
-    let devices = yield enumerateDevices().catch(error => []);
-    if (filterByKind) {
-        devices = devices.filter(({ kind }) => kind === filterByKind);
-    }
-    return devices;
-});
 const getSupportedConstraints = () => navigator.mediaDevices.getSupportedConstraints();
 const streamIsValid = (stream) => stream && stream instanceof MediaStream;
 const attachMediaStream = (tag, stream) => {
@@ -62,11 +54,6 @@ const toggleMuteMediaElement = (tag) => {
 const setMediaElementSinkId = (tag, deviceId) => __awaiter(void 0, void 0, void 0, function* () {
     const element = findElementByType(tag);
     if (element === null) {
-        logger.info('No HTMLMediaElement to attach the speakerId');
-        return false;
-    }
-    if (typeof deviceId !== 'string') {
-        logger.info(`Invalid speaker deviceId: '${deviceId}'`);
         return false;
     }
     try {
@@ -80,56 +67,8 @@ const setMediaElementSinkId = (tag, deviceId) => __awaiter(void 0, void 0, void
 const sdpToJsonHack = sdp => sdp;
 const stopStream = (stream) => {
     if (streamIsValid(stream)) {
-        stream.getTracks().forEach(stopTrack);
+        stream.getTracks().forEach(t => t.stop());
     }
     stream = null;
 };
-const stopTrack = (track) => {
-    if (track && track.readyState === 'live') {
-        track.stop();
-        track.dispatchEvent(new Event('ended'));
-    }
-};
-const getHostname = () => window.location.hostname;
-const buildVideoElementByTrack = (videoTrack, streamIds = []) => {
-    const video = document.createElement('video');
-    video.muted = true;
-    video.autoplay = true;
-    video.playsinline = true;
-    video._streamIds = streamIds;
-    const mediaStream = new MediaStream([videoTrack]);
-    video.srcObject = mediaStream;
-    const onCanPlay = () => console.debug('video can play!');
-    const onPlay = () => console.debug('video is now playing...');
-    video.addEventListener('play', onPlay);
-    video.addEventListener('canplay', onCanPlay);
-    videoTrack.addEventListener('ended', () => {
-        video.removeEventListener('play', onPlay);
-        video.removeEventListener('canplay', onCanPlay);
-        video.srcObject = null;
-        delete video._streamIds;
-        video.remove();
-    });
-    return video;
-};
-const buildAudioElementByTrack = (audioTrack, streamIds = []) => {
-    const audio = new Audio();
-    audio.autoplay = true;
-    audio.playsinline = true;
-    audio._streamIds = streamIds;
-    const mediaStream = new MediaStream([audioTrack]);
-    audio.srcObject = mediaStream;
-    const onCanPlay = () => console.debug('audio can play!');
-    const onPlay = () => console.debug('audio is now playing...');
-    audio.addEventListener('play', onPlay);
-    audio.addEventListener('canplay', onCanPlay);
-    audioTrack.addEventListener('ended', () => {
-        audio.removeEventListener('play', onPlay);
-        audio.removeEventListener('canplay', onCanPlay);
-        audio.srcObject = null;
-        delete audio._streamIds;
-        audio.remove();
-    });
-    return audio;
-};
-export { RTCPeerConnection, getUserMedia, getDisplayMedia, enumerateDevices, enumerateDevicesByKind, getSupportedConstraints, streamIsValid, attachMediaStream, detachMediaStream, sdpToJsonHack, stopStream, stopTrack, muteMediaElement, unmuteMediaElement, toggleMuteMediaElement, setMediaElementSinkId, getHostname, buildVideoElementByTrack, buildAudioElementByTrack, };
+export { RTCPeerConnection, getUserMedia, getDisplayMedia, enumerateDevices, getSupportedConstraints, streamIsValid, attachMediaStream, detachMediaStream, sdpToJsonHack, stopStream, muteMediaElement, unmuteMediaElement, toggleMuteMediaElement, setMediaElementSinkId };

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

@@ -0,0 +1,76 @@
+import BrowserSession from '../BrowserSession';
+import Peer from './Peer';
+import { State, Direction } from './constants';
+import { CallOptions, IWebRTCCall } from './interfaces';
+export default abstract class BaseCall implements IWebRTCCall {
+    protected session: BrowserSession;
+    id: string;
+    state: string;
+    prevState: string;
+    direction: Direction;
+    peer: Peer;
+    options: CallOptions;
+    cause: string;
+    causeCode: number;
+    channels: string[];
+    role: string;
+    extension: string;
+    private _state;
+    private _prevState;
+    private gotAnswer;
+    private gotEarly;
+    private _lastSerno;
+    private _targetNodeId;
+    private _iceTimeout;
+    private _iceDone;
+    constructor(session: BrowserSession, opts?: CallOptions);
+    get nodeId(): string;
+    set nodeId(what: string);
+    get localStream(): MediaStream;
+    get remoteStream(): MediaStream;
+    get memberChannel(): string;
+    invite(): void;
+    answer(params?: {
+        iceTransportPolicy?: RTCConfiguration['iceTransportPolicy'];
+    }): void;
+    hangup(params?: any, execute?: boolean): void;
+    transfer(destination: string): void;
+    replace(replaceCallID: string): void;
+    hold(): any;
+    unhold(): any;
+    toggleHold(): any;
+    dtmf(dtmf: string): void;
+    message(to: string, body: string): void;
+    muteAudio(): void;
+    unmuteAudio(): void;
+    toggleAudioMute(): void;
+    setAudioInDevice(deviceId: string): Promise<void>;
+    muteVideo(): void;
+    unmuteVideo(): void;
+    toggleVideoMute(): void;
+    setVideoDevice(deviceId: string): Promise<void>;
+    deaf(): void;
+    undeaf(): void;
+    toggleDeaf(): void;
+    setState(state: State): void;
+    handleMessage(msg: any): void;
+    handleConferenceUpdate(packet: any, initialPvtData: any): Promise<string>;
+    _addChannel(channel: string): void;
+    private _subscribeConferenceChat;
+    private _subscribeConferenceInfo;
+    private _confControl;
+    private _subscribeConferenceModerator;
+    private _handleChangeHoldStateSuccess;
+    private _handleChangeHoldStateError;
+    private _onRemoteSdp;
+    private _requestAnotherLocalDescription;
+    private _onIceSdp;
+    private _registerPeerEvents;
+    private _checkConferenceSerno;
+    private _onMediaError;
+    private _dispatchConferenceUpdate;
+    private _dispatchNotification;
+    private _execute;
+    private _init;
+    protected _finalize(): void;
+}