@signalwire/js 1.2.5-beta.1 → 1.2.8

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

@@ -11,9 +11,10 @@ import logger from '../util/logger';
 import Call from './Call';
 import { checkSubscribeResponse } from './helpers';
 import { Result } from '../messages/Verto';
-import { SwEvent, VertoMethod, NOTIFICATION_TYPE } from '../util/constants';
+import { SwEvent } from '../util/constants';
+import { VertoMethod, NOTIFICATION_TYPE } from './constants';
 import { trigger, deRegister } from '../services/Handler';
-import { State, ConferenceAction } from '../util/constants/call';
+import { State, ConferenceAction } from './constants';
 import { MCULayoutEventHandler } from './LayoutHandler';
 class VertoHandler {
     constructor(session) {

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

@@ -0,0 +1,74 @@
+import { CallOptions } from './interfaces';
+export declare enum PeerType {
+    Offer = "offer",
+    Answer = "answer"
+}
+export declare enum Direction {
+    Inbound = "inbound",
+    Outbound = "outbound"
+}
+export declare enum VertoMethod {
+    Invite = "verto.invite",
+    Attach = "verto.attach",
+    Answer = "verto.answer",
+    Info = "verto.info",
+    Display = "verto.display",
+    Media = "verto.media",
+    Event = "verto.event",
+    Bye = "verto.bye",
+    Punt = "verto.punt",
+    Broadcast = "verto.broadcast",
+    Subscribe = "verto.subscribe",
+    Unsubscribe = "verto.unsubscribe",
+    ClientReady = "verto.clientReady",
+    Modify = "verto.modify"
+}
+export declare const NOTIFICATION_TYPE: {
+    generic: string;
+    "verto.display": string;
+    "verto.attach": string;
+    conferenceUpdate: string;
+    callUpdate: string;
+    vertoClientReady: string;
+    userMediaError: string;
+    refreshToken: string;
+};
+export declare const DEFAULT_CALL_OPTIONS: CallOptions;
+export declare enum State {
+    New = 0,
+    Requesting = 1,
+    Trying = 2,
+    Recovering = 3,
+    Ringing = 4,
+    Answering = 5,
+    Early = 6,
+    Active = 7,
+    Held = 8,
+    Hangup = 9,
+    Destroy = 10,
+    Purge = 11
+}
+export declare enum Role {
+    Participant = "participant",
+    Moderator = "moderator"
+}
+export declare enum ConferenceAction {
+    Join = "join",
+    Leave = "leave",
+    Bootstrap = "bootstrap",
+    Add = "add",
+    Modify = "modify",
+    Delete = "delete",
+    Clear = "clear",
+    ChatMessage = "chatMessage",
+    LayerInfo = "layerInfo",
+    LogoInfo = "logoInfo",
+    LayoutInfo = "layoutInfo",
+    LayoutList = "layoutList",
+    ModCmdResponse = "modCommandResponse"
+}
+export declare enum DeviceType {
+    Video = "videoinput",
+    AudioIn = "audioinput",
+    AudioOut = "audiooutput"
+}

package/dist/esm/common/src/{util/constants/call.js → webrtc/constants.js}

@@ -1,3 +1,40 @@
+export var PeerType;
+(function (PeerType) {
+    PeerType["Offer"] = "offer";
+    PeerType["Answer"] = "answer";
+})(PeerType || (PeerType = {}));
+export var Direction;
+(function (Direction) {
+    Direction["Inbound"] = "inbound";
+    Direction["Outbound"] = "outbound";
+})(Direction || (Direction = {}));
+export var VertoMethod;
+(function (VertoMethod) {
+    VertoMethod["Invite"] = "verto.invite";
+    VertoMethod["Attach"] = "verto.attach";
+    VertoMethod["Answer"] = "verto.answer";
+    VertoMethod["Info"] = "verto.info";
+    VertoMethod["Display"] = "verto.display";
+    VertoMethod["Media"] = "verto.media";
+    VertoMethod["Event"] = "verto.event";
+    VertoMethod["Bye"] = "verto.bye";
+    VertoMethod["Punt"] = "verto.punt";
+    VertoMethod["Broadcast"] = "verto.broadcast";
+    VertoMethod["Subscribe"] = "verto.subscribe";
+    VertoMethod["Unsubscribe"] = "verto.unsubscribe";
+    VertoMethod["ClientReady"] = "verto.clientReady";
+    VertoMethod["Modify"] = "verto.modify";
+})(VertoMethod || (VertoMethod = {}));
+export const NOTIFICATION_TYPE = {
+    generic: 'event',
+    [VertoMethod.Display]: 'participantData',
+    [VertoMethod.Attach]: 'participantData',
+    conferenceUpdate: 'conferenceUpdate',
+    callUpdate: 'callUpdate',
+    vertoClientReady: 'vertoClientReady',
+    userMediaError: 'userMediaError',
+    refreshToken: 'refreshToken',
+};
 export const DEFAULT_CALL_OPTIONS = {
     destinationNumber: '',
     remoteCallerName: 'Outbound Call',
@@ -10,9 +47,6 @@ export const DEFAULT_CALL_OPTIONS = {
     attach: false,
     screenShare: false,
     userVariables: {},
-    googleMaxBitrate: 2048,
-    googleMinBitrate: 0,
-    googleStartBitrate: 1024,
 };
 export var State;
 (function (State) {
@@ -50,3 +84,9 @@ export var ConferenceAction;
     ConferenceAction["LayoutList"] = "layoutList";
     ConferenceAction["ModCmdResponse"] = "modCommandResponse";
 })(ConferenceAction || (ConferenceAction = {}));
+export var DeviceType;
+(function (DeviceType) {
+    DeviceType["Video"] = "videoinput";
+    DeviceType["AudioIn"] = "audioinput";
+    DeviceType["AudioOut"] = "audiooutput";
+})(DeviceType || (DeviceType = {}));

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

@@ -1,6 +1,6 @@
-import { CallOptions } from '../util/interfaces';
+import { CallOptions } from './interfaces';
 declare const getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
-declare const getDevices: (kind?: string) => Promise<MediaDeviceInfo[]>;
+declare const getDevices: (kind?: string, fullList?: boolean) => Promise<MediaDeviceInfo[]>;
 declare const scanResolutions: (deviceId: string) => Promise<any[]>;
 declare const getMediaConstraints: (options: CallOptions) => Promise<MediaStreamConstraints>;
 declare const assureDeviceId: (id: string, label: string, kind: MediaDeviceKind) => Promise<string>;

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

@@ -10,8 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import logger from '../util/logger';
 import * as WebRTC from '../util/webrtc';
 import { isDefined } from '../util/helpers';
-import { stopStream } from '../util/webrtc';
-import { DeviceType } from '../util/constants';
+import { DeviceType } from './constants';
 const getUserMedia = (constraints) => __awaiter(void 0, void 0, void 0, function* () {
     logger.info('RTCService.getUserMedia', constraints);
     const { audio, video } = constraints;
@@ -32,17 +31,20 @@ const _constraintsByKind = (kind = null) => {
         video: !kind || kind === DeviceType.Video
     };
 };
-const getDevices = (kind = null) => __awaiter(void 0, void 0, void 0, function* () {
+const getDevices = (kind = null, fullList = false) => __awaiter(void 0, void 0, void 0, function* () {
     let devices = yield WebRTC.enumerateDevices().catch(error => []);
     if (kind) {
         devices = devices.filter((d) => d.kind === kind);
     }
-    const invalid = devices.length && devices.every((d) => (!d.deviceId || !d.label));
-    if (invalid) {
+    const valid = devices.length && devices.every((d) => (d.deviceId && d.label));
+    if (!valid) {
         const stream = yield WebRTC.getUserMedia(_constraintsByKind(kind));
         WebRTC.stopStream(stream);
         return getDevices(kind);
     }
+    if (fullList === true) {
+        return devices;
+    }
     const found = [];
     devices = devices.filter(({ kind, groupId }) => {
         if (!groupId) {
@@ -71,7 +73,7 @@ const scanResolutions = (deviceId) => __awaiter(void 0, void 0, void 0, function
             supported.push({ resolution: `${width}x${height}`, width, height });
         }
     }
-    stopStream(stream);
+    WebRTC.stopStream(stream);
     return supported;
 });
 const getMediaConstraints = (options) => __awaiter(void 0, void 0, void 0, function* () {
@@ -100,15 +102,7 @@ const getMediaConstraints = (options) => __awaiter(void 0, void 0, void 0, funct
     return { audio, video };
 });
 const assureDeviceId = (id, label, kind) => __awaiter(void 0, void 0, void 0, function* () {
-    const devices = yield WebRTC.enumerateDevices()
-        .catch(error => [])
-        .then(all => all.filter((d) => d.kind === kind));
-    const invalid = devices.length && devices.every((d) => (!d.deviceId || !d.label));
-    if (invalid) {
-        const stream = yield WebRTC.getUserMedia(_constraintsByKind(kind));
-        WebRTC.stopStream(stream);
-        return assureDeviceId(id, label, kind);
-    }
+    const devices = yield getDevices(kind, true);
     for (let i = 0; i < devices.length; i++) {
         const { deviceId, label: deviceLabel } = devices[i];
         if (id === deviceId || label === deviceLabel) {

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

@@ -0,0 +1,87 @@
+export interface CallOptions {
+    destinationNumber: string;
+    remoteCallerName: string;
+    remoteCallerNumber: string;
+    callerName: string;
+    callerNumber: string;
+    id?: string;
+    remoteSdp?: string;
+    localStream?: MediaStream;
+    remoteStream?: MediaStream;
+    localElement?: HTMLMediaElement | string | Function;
+    remoteElement?: HTMLMediaElement | string | Function;
+    iceServers?: RTCIceServer[];
+    audio?: boolean | MediaTrackConstraints;
+    video?: boolean | MediaTrackConstraints;
+    attach?: boolean;
+    useStereo?: boolean;
+    micId?: string;
+    micLabel?: string;
+    camId?: string;
+    camLabel?: string;
+    speakerId?: string;
+    userVariables?: Object;
+    screenShare?: boolean;
+    onNotification?: Function;
+    googleMaxBitrate?: number;
+    googleMinBitrate?: number;
+    googleStartBitrate?: number;
+}
+export interface IWebRTCCall {
+    id: string;
+    state: string;
+    prevState: string;
+    direction: string;
+    options: CallOptions;
+    cause: string;
+    causeCode: number;
+    channels: string[];
+    role: string;
+    extension: string;
+    localStream: MediaStream;
+    remoteStream: MediaStream;
+    invite: () => void;
+    answer: () => void;
+    hangup: (params: any, execute: boolean) => void;
+    transfer: (destination: string) => void;
+    replace: (replaceCallID: string) => void;
+    hold: () => void;
+    unhold: () => void;
+    toggleHold: () => void;
+    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: any) => void;
+    handleMessage: (msg: any) => void;
+    _addChannel: (laChannel: any) => void;
+    handleConferenceUpdate: (packet: any, pvtData: any) => Promise<string>;
+    startScreenShare?: (opts?: object) => Promise<IWebRTCCall>;
+    stopScreenShare?: () => void;
+    setAudioOutDevice?: (deviceId: string) => Promise<boolean>;
+    switchCamera?: () => void;
+    setSpeakerPhone?: (flag: boolean) => void;
+}
+export interface ICantinaAuthParams {
+    hostname?: string;
+}
+export interface ICantinaUser {
+    first_name: string;
+    last_name: string;
+    email: string;
+    phone: string;
+    avatar: string;
+    project: string;
+    jwt_token: string;
+    scopes: string[];
+    config?: object;
+}

package/dist/esm/js/index.d.ts

@@ -1,4 +1,6 @@
 import Relay from './src/SignalWire';
 import Verto from './src/Verto';
-export declare const VERSION = "1.2.5-beta.1";
-export { Relay, Verto };
+import CantinaAuth from '../common/src/webrtc/CantinaAuth';
+export declare const VERSION = "1.2.8";
+export { Relay, Verto, CantinaAuth };
+export * from '../common/src/util/interfaces';

package/dist/esm/js/index.js

@@ -1,6 +1,7 @@
 import Relay from './src/SignalWire';
 import Verto from './src/Verto';
 import { setAgentName } from '../common/src/messages/blade/Connect';
-export const VERSION = '1.2.5-beta.1';
+import CantinaAuth from '../common/src/webrtc/CantinaAuth';
+export const VERSION = '1.2.8';
 setAgentName(`JavaScript SDK/${VERSION}`);
-export { Relay, Verto };
+export { Relay, Verto, CantinaAuth };

package/dist/esm/js/src/SignalWire.d.ts

@@ -1,6 +1,6 @@
 import BrowserSession from '../../common/src/BrowserSession';
 import BaseMessage from '../../common/src/messages/BaseMessage';
-import { CallOptions } from '../../common/src/util/interfaces';
+import { CallOptions } from '../../common/src/webrtc/interfaces';
 import Call from '../../common/src/webrtc/Call';
 export default class SignalWire extends BrowserSession {
     execute(message: BaseMessage): any;

package/dist/esm/js/src/Verto.d.ts

@@ -1,9 +1,11 @@
 import BrowserSession from '../../common/src/BrowserSession';
-import { SubscribeParams, BroadcastParams, CallOptions } from '../../common/src/util/interfaces';
+import { SubscribeParams, BroadcastParams } from '../../common/src/util/interfaces';
+import { CallOptions } from '../../common/src/webrtc/interfaces';
 import Call from '../../common/src/webrtc/Call';
 export declare const VERTO_PROTOCOL = "verto-protocol";
 export default class Verto extends BrowserSession {
     relayProtocol: string;
+    timeoutErrorCode: number;
     validateOptions(): boolean;
     newCall(options: CallOptions): Call;
     broadcast(params: BroadcastParams): void;

package/dist/esm/js/src/Verto.js

@@ -19,6 +19,7 @@ export default class Verto extends BrowserSession {
     constructor() {
         super(...arguments);
         this.relayProtocol = VERTO_PROTOCOL;
+        this.timeoutErrorCode = -329990;
     }
     validateOptions() {
         const { host, login, passwd, password } = this.options;
@@ -46,6 +47,10 @@ export default class Verto extends BrowserSession {
         return __awaiter(this, void 0, void 0, function* () {
             this._idle = false;
             const { login, password, passwd, userVariables } = this.options;
+            if (this.sessionid) {
+                const sessidLogin = new Login(undefined, undefined, this.sessionid, undefined);
+                yield this.execute(sessidLogin).catch(console.error);
+            }
             const msg = new Login(login, (password || passwd), this.sessionid, userVariables);
             const response = yield this.execute(msg).catch(this._handleLoginError);
             if (response) {