@signalwire/js 1.4.2-rc.1 → 1.5.0

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

@@ -8,10 +8,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import logger from '../util/logger';
-import { getUserMedia, getMediaConstraints, sdpStereoHack, sdpBitrateHack } from './helpers';
+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 { attachMediaStream, muteMediaElement, sdpToJsonHack, RTCPeerConnection, streamIsValid, } from './WebRTC';
 import { isFunction } from '../util/helpers';
 import { trigger } from '../services/Handler';
 import { filterIceServers } from './helpers';
@@ -23,7 +23,10 @@ export default class Peer {
         this.onSdpReadyTwice = null;
         this._negotiating = false;
         logger.info('New Peer with type:', this.type, 'Options:', this.options);
-        this._constraints = { offerToReceiveAudio: true, offerToReceiveVideo: true };
+        this._constraints = {
+            offerToReceiveAudio: true,
+            offerToReceiveVideo: true,
+        };
         this._sdpReady = this._sdpReady.bind(this);
         this._init();
     }
@@ -45,7 +48,7 @@ export default class Peer {
     _init() {
         return __awaiter(this, void 0, void 0, function* () {
             this.instance = RTCPeerConnection(this._config());
-            this.instance.onsignalingstatechange = event => {
+            this.instance.onsignalingstatechange = (event) => {
                 switch (this.instance.signalingState) {
                     case 'stable':
                         break;
@@ -56,22 +59,24 @@ export default class Peer {
                         this._negotiating = true;
                 }
             };
-            this.instance.onnegotiationneeded = event => {
+            this.instance.onnegotiationneeded = (event) => {
                 if (this._negotiating) {
                     logger.debug('Skip twice onnegotiationneeded..');
                     return;
                 }
                 this.startNegotiation();
             };
-            this.options.localStream = yield this._retrieveLocalStream()
-                .catch(error => {
+            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));
+                    const tracks = localStream.getTracks();
+                    for (const track of tracks) {
+                        yield this.instance.addTrack(track, localStream);
+                    }
                 }
                 else {
                     this.instance.addStream(localStream);
@@ -90,10 +95,11 @@ export default class Peer {
         if (!this._isOffer()) {
             return;
         }
-        this.instance.createOffer(this._constraints)
+        this.instance
+            .createOffer(this._constraints)
             .then(this._setLocalDescription.bind(this))
             .then(this._sdpReady)
-            .catch(error => logger.error('Peer _createOffer error:', error));
+            .catch((error) => logger.error('Peer _createOffer error:', error));
     }
     _createAnswer() {
         if (!this._isAnswer()) {
@@ -101,12 +107,16 @@ export default class Peer {
         }
         const { remoteSdp, useStereo } = this.options;
         const sdp = useStereo ? sdpStereoHack(remoteSdp) : remoteSdp;
-        const sessionDescr = sdpToJsonHack({ sdp, type: PeerType.Offer });
-        this.instance.setRemoteDescription(sessionDescr)
+        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));
+            .catch((error) => logger.error('Peer _createAnswer error:', error));
     }
     _setLocalDescription(sessionDescription) {
         const { useStereo, googleMaxBitrate, googleMinBitrate, googleStartBitrate } = this.options;
@@ -132,7 +142,7 @@ export default class Peer {
         const remoteVideo = sdp ? sdpHasVideo(sdp) : false;
         const sharedConstraints = {
             audio: localAudio && remoteAudio,
-            video: localVideo && remoteVideo
+            video: localVideo && remoteVideo,
         };
         return sharedConstraints;
     }
@@ -146,7 +156,10 @@ export default class Peer {
             if (this._isAnswer()) {
                 const { remoteSdp, useStereo } = this.options;
                 const sdp = useStereo ? sdpStereoHack(remoteSdp) : remoteSdp;
-                const sessionDescr = sdpToJsonHack({ sdp, type: PeerType.Offer });
+                const sessionDescr = sdpToJsonHack({
+                    sdp,
+                    type: PeerType.Offer,
+                });
                 sharedConstraints = this._getSharedConstraints(localConstraints, sessionDescr.sdp);
             }
             return getUserMedia(sharedConstraints);
@@ -159,8 +172,10 @@ export default class Peer {
         return this.type === PeerType.Answer;
     }
     _config() {
-        const { iceServers = [], iceTransportPolicy = 'all', disableUdpIceServers = false } = this.options;
-        const filteredIceServers = filterIceServers(iceServers, { disableUdpIceServers });
+        const { iceServers = [], iceTransportPolicy = 'all', disableUdpIceServers = false, } = this.options;
+        const filteredIceServers = filterIceServers(iceServers, {
+            disableUdpIceServers,
+        });
         const config = {
             iceTransportPolicy,
             sdpSemantics: 'unified-plan',
@@ -171,14 +186,17 @@ export default class Peer {
         return config;
     }
     _getSenderByKind(kind) {
-        if (this.instance) {
-            return this.instance.getSenders().find(({ track }) => (track && track.kind === kind));
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.instance) {
+                const senders = yield this.instance.getSenders();
+                return senders.find(({ track }) => track && track.kind === kind);
+            }
+        });
     }
     applyMediaConstraints(kind, constraints) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const sender = this._getSenderByKind(kind);
+                const sender = yield this._getSenderByKind(kind);
                 if (!sender || !sender.track) {
                     return logger.info('No sender to apply constraints', kind, constraints);
                 }

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

@@ -0,0 +1,51 @@
+import * as WebRTC from '../util/webrtc';
+export interface IWebRTCOverridesManager {
+    RTCPeerConnection: (params: any) => RTCPeerConnection;
+    getUserMedia: typeof WebRTC.getUserMedia;
+    getDisplayMedia: typeof WebRTC.getDisplayMedia;
+    enumerateDevices: typeof WebRTC.enumerateDevices;
+    getSupportedConstraints: typeof WebRTC.getSupportedConstraints;
+    attachMediaStream: typeof WebRTC.attachMediaStream;
+    streamIsValid: typeof WebRTC.streamIsValid;
+}
+export declare class WebRTCOverridesManager implements IWebRTCOverridesManager {
+    private constructor();
+    private static _instance;
+    private _RTCPeerConnection;
+    private _getUserMedia;
+    private _getDisplayMedia;
+    private _enumerateDevices;
+    private _getSupportedConstraints;
+    private _attachMediaStream;
+    private _streamIsValid;
+    static getInstance(): WebRTCOverridesManager;
+    get RTCPeerConnection(): (params: any) => RTCPeerConnection;
+    set RTCPeerConnection(value: (params: any) => RTCPeerConnection);
+    get getUserMedia(): typeof WebRTC.getUserMedia;
+    set getUserMedia(value: typeof WebRTC.getUserMedia);
+    get getDisplayMedia(): (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+    set getDisplayMedia(value: (constraints: MediaStreamConstraints) => Promise<MediaStream>);
+    get enumerateDevices(): () => Promise<MediaDeviceInfo[]>;
+    set enumerateDevices(value: () => Promise<MediaDeviceInfo[]>);
+    get getSupportedConstraints(): () => MediaTrackSupportedConstraints;
+    set getSupportedConstraints(value: () => MediaTrackSupportedConstraints);
+    set attachMediaStream(value: (tag: any, stream: MediaStream) => void);
+    get attachMediaStream(): (tag: any, stream: MediaStream) => void;
+    set streamIsValid(value: (stream: MediaStream) => boolean);
+    get streamIsValid(): (stream: MediaStream) => boolean;
+}
+declare const RTCPeerConnection: (params: any) => RTCPeerConnection;
+declare const getUserMedia: (params: any) => Promise<MediaStream>;
+declare const getDisplayMedia: (params: any) => Promise<MediaStream>;
+declare const enumerateDevices: () => Promise<MediaDeviceInfo[]>;
+declare const getSupportedConstraints: () => MediaTrackSupportedConstraints;
+declare const streamIsValid: (stream: any) => boolean;
+declare const attachMediaStream: (tag: any, stream: MediaStream) => void;
+declare const detachMediaStream: (tag: any) => void;
+declare const muteMediaElement: (tag: any) => void;
+declare const unmuteMediaElement: (tag: any) => void;
+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;
+export { RTCPeerConnection, getUserMedia, getDisplayMedia, enumerateDevices, getSupportedConstraints, streamIsValid, attachMediaStream, detachMediaStream, sdpToJsonHack, stopStream, muteMediaElement, unmuteMediaElement, toggleMuteMediaElement, setMediaElementSinkId, };

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

@@ -0,0 +1,91 @@
+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 { normalizeAsyncAPIs } from '../util/helpers';
+import * as WebRTC from '../util/webrtc';
+export class WebRTCOverridesManager {
+    constructor() { }
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new WebRTCOverridesManager();
+        }
+        return this._instance;
+    }
+    get RTCPeerConnection() {
+        return (params) => {
+            var _a;
+            const peerConnectionBuilder = (_a = this._RTCPeerConnection) !== null && _a !== void 0 ? _a : WebRTC.RTCPeerConnection;
+            const peerConnectionInstance = peerConnectionBuilder(params);
+            return normalizeAsyncAPIs(peerConnectionInstance, [
+                'addTrack',
+                'getSender',
+            ]);
+        };
+    }
+    set RTCPeerConnection(value) {
+        this._RTCPeerConnection = value;
+    }
+    get getUserMedia() {
+        var _a;
+        return (_a = this._getUserMedia) !== null && _a !== void 0 ? _a : WebRTC.getUserMedia;
+    }
+    set getUserMedia(value) {
+        this._getUserMedia = value;
+    }
+    get getDisplayMedia() {
+        var _a;
+        return (_a = this._getDisplayMedia) !== null && _a !== void 0 ? _a : WebRTC.getDisplayMedia;
+    }
+    set getDisplayMedia(value) {
+        this._getDisplayMedia = value;
+    }
+    get enumerateDevices() {
+        var _a;
+        return (_a = this._enumerateDevices) !== null && _a !== void 0 ? _a : WebRTC.enumerateDevices;
+    }
+    set enumerateDevices(value) {
+        this._enumerateDevices = value;
+    }
+    get getSupportedConstraints() {
+        var _a;
+        return (_a = this._getSupportedConstraints) !== null && _a !== void 0 ? _a : WebRTC.getSupportedConstraints;
+    }
+    set getSupportedConstraints(value) {
+        this._getSupportedConstraints = value;
+    }
+    set attachMediaStream(value) {
+        this._attachMediaStream = value;
+    }
+    get attachMediaStream() {
+        var _a;
+        return (_a = this._attachMediaStream) !== null && _a !== void 0 ? _a : WebRTC.attachMediaStream;
+    }
+    set streamIsValid(value) {
+        this._streamIsValid = value;
+    }
+    get streamIsValid() {
+        var _a;
+        return (_a = this._streamIsValid) !== null && _a !== void 0 ? _a : WebRTC.streamIsValid;
+    }
+}
+const RTCPeerConnection = (params) => WebRTCOverridesManager.getInstance().RTCPeerConnection(params);
+const getUserMedia = (params) => WebRTCOverridesManager.getInstance().getUserMedia(params);
+const getDisplayMedia = (params) => WebRTCOverridesManager.getInstance().getDisplayMedia(params);
+const enumerateDevices = () => WebRTCOverridesManager.getInstance().enumerateDevices();
+const getSupportedConstraints = () => WebRTCOverridesManager.getInstance().getSupportedConstraints();
+const streamIsValid = (stream) => WebRTCOverridesManager.getInstance().streamIsValid(stream);
+const attachMediaStream = (tag, stream) => WebRTCOverridesManager.getInstance().attachMediaStream(tag, stream);
+const detachMediaStream = (tag) => WebRTC.detachMediaStream(tag);
+const muteMediaElement = (tag) => WebRTC.muteMediaElement(tag);
+const unmuteMediaElement = (tag) => WebRTC.unmuteMediaElement(tag);
+const toggleMuteMediaElement = (tag) => WebRTC.toggleMuteMediaElement(tag);
+const setMediaElementSinkId = (tag, deviceId) => __awaiter(void 0, void 0, void 0, function* () { return WebRTC.setMediaElementSinkId(tag, deviceId); });
+const sdpToJsonHack = (sdp) => WebRTC.sdpToJsonHack(sdp);
+const stopStream = (stream) => WebRTC.stopStream(stream);
+export { RTCPeerConnection, getUserMedia, getDisplayMedia, enumerateDevices, getSupportedConstraints, streamIsValid, attachMediaStream, detachMediaStream, sdpToJsonHack, stopStream, muteMediaElement, unmuteMediaElement, toggleMuteMediaElement, setMediaElementSinkId, };

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

@@ -30,4 +30,4 @@ interface FilterIceServersOptions {
 declare const filterIceServers: (servers: RTCIceServer[], options?: FilterIceServersOptions) => RTCIceServer[];
 declare const sdpHasAudio: (sdp?: string) => boolean;
 declare const sdpHasVideo: (sdp?: string) => boolean;
-export { getUserMedia, getDevices, scanResolutions, getMediaConstraints, assureDeviceId, removeUnsupportedConstraints, checkDeviceIdConstraints, sdpStereoHack, sdpMediaOrderHack, sdpBitrateHack, checkSubscribeResponse, destructSubscribeResponse, enableAudioTracks, disableAudioTracks, toggleAudioTracks, enableVideoTracks, disableVideoTracks, toggleVideoTracks, filterIceServers, sdpHasAudio, sdpHasVideo };
+export { getUserMedia, getDevices, scanResolutions, getMediaConstraints, assureDeviceId, removeUnsupportedConstraints, checkDeviceIdConstraints, sdpStereoHack, sdpMediaOrderHack, sdpBitrateHack, checkSubscribeResponse, destructSubscribeResponse, enableAudioTracks, disableAudioTracks, toggleAudioTracks, enableVideoTracks, disableVideoTracks, toggleVideoTracks, filterIceServers, sdpHasAudio, sdpHasVideo, };

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

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import logger from '../util/logger';
-import * as WebRTC from '../util/webrtc';
+import * as WebRTC from './WebRTC';
 import { isDefined } from '../util/helpers';
 import { DeviceType } from './constants';
 const getUserMedia = (constraints) => __awaiter(void 0, void 0, void 0, function* () {
@@ -28,15 +28,16 @@ const getUserMedia = (constraints) => __awaiter(void 0, void 0, void 0, function
 const _constraintsByKind = (kind = null) => {
     return {
         audio: !kind || kind === DeviceType.AudioIn,
-        video: !kind || kind === DeviceType.Video
+        video: !kind || kind === DeviceType.Video,
     };
 };
 const getDevices = (kind = null, fullList = false) => __awaiter(void 0, void 0, void 0, function* () {
-    let devices = yield WebRTC.enumerateDevices().catch(error => []);
+    let devices = yield WebRTC.enumerateDevices().catch((error) => []);
     if (kind) {
         devices = devices.filter((d) => d.kind === kind);
     }
-    const valid = devices.length && devices.every((d) => (d.deviceId && d.label));
+    const valid = devices.length &&
+        devices.every((d) => d.deviceId && d.label);
     if (!valid) {
         const stream = yield WebRTC.getUserMedia(_constraintsByKind(kind));
         WebRTC.stopStream(stream);
@@ -59,14 +60,23 @@ const getDevices = (kind = null, fullList = false) => __awaiter(void 0, void 0,
     });
     return devices;
 });
-const resolutionList = [[320, 240], [640, 360], [640, 480], [1280, 720], [1920, 1080]];
+const resolutionList = [
+    [320, 240],
+    [640, 360],
+    [640, 480],
+    [1280, 720],
+    [1920, 1080],
+];
 const scanResolutions = (deviceId) => __awaiter(void 0, void 0, void 0, function* () {
     const supported = [];
-    const stream = yield getUserMedia({ video: { deviceId: { exact: deviceId } } });
+    const stream = yield getUserMedia({
+        video: { deviceId: { exact: deviceId } },
+    });
     const videoTrack = stream.getVideoTracks()[0];
     for (let i = 0; i < resolutionList.length; i++) {
         const [width, height] = resolutionList[i];
-        const success = yield videoTrack.applyConstraints({ width: { exact: width }, height: { exact: height } })
+        const success = yield videoTrack
+            .applyConstraints({ width: { exact: width }, height: { exact: height } })
             .then(() => true)
             .catch(() => false);
         if (success) {
@@ -80,7 +90,7 @@ const getMediaConstraints = (options) => __awaiter(void 0, void 0, void 0, funct
     let { audio = true, micId } = options;
     const { micLabel = '' } = options;
     if (micId) {
-        micId = yield assureDeviceId(micId, micLabel, DeviceType.AudioIn).catch(error => null);
+        micId = yield assureDeviceId(micId, micLabel, DeviceType.AudioIn).catch((error) => null);
         if (micId) {
             if (typeof audio === 'boolean') {
                 audio = {};
@@ -91,7 +101,7 @@ const getMediaConstraints = (options) => __awaiter(void 0, void 0, void 0, funct
     let { video = false, camId } = options;
     const { camLabel = '' } = options;
     if (camId) {
-        camId = yield assureDeviceId(camId, camLabel, DeviceType.Video).catch(error => null);
+        camId = yield assureDeviceId(camId, camLabel, DeviceType.Video).catch((error) => null);
         if (camId) {
             if (typeof video === 'boolean') {
                 video = {};
@@ -113,8 +123,10 @@ const assureDeviceId = (id, label, kind) => __awaiter(void 0, void 0, void 0, fu
 });
 const removeUnsupportedConstraints = (constraints) => {
     const supported = WebRTC.getSupportedConstraints();
-    Object.keys(constraints).map(key => {
-        if (!supported.hasOwnProperty(key) || constraints[key] === null || constraints[key] === undefined) {
+    Object.keys(constraints).map((key) => {
+        if (!supported.hasOwnProperty(key) ||
+            constraints[key] === null ||
+            constraints[key] === undefined) {
             delete constraints[key];
         }
     });
@@ -122,7 +134,7 @@ const removeUnsupportedConstraints = (constraints) => {
 const checkDeviceIdConstraints = (id, label, kind, constraints) => __awaiter(void 0, void 0, void 0, function* () {
     const { deviceId } = constraints;
     if (!isDefined(deviceId) && (id || label)) {
-        const deviceId = yield assureDeviceId(id, label, kind).catch(error => null);
+        const deviceId = yield assureDeviceId(id, label, kind).catch((error) => null);
         if (deviceId) {
             constraints.deviceId = { exact: deviceId };
         }
@@ -132,7 +144,7 @@ const checkDeviceIdConstraints = (id, label, kind, constraints) => __awaiter(voi
 const sdpStereoHack = (sdp) => {
     const endOfLine = '\r\n';
     const sdpLines = sdp.split(endOfLine);
-    const opusIndex = sdpLines.findIndex(s => /^a=rtpmap/.test(s) && /opus\/48000/.test(s));
+    const opusIndex = sdpLines.findIndex((s) => /^a=rtpmap/.test(s) && /opus\/48000/.test(s));
     if (opusIndex < 0) {
         return sdp;
     }
@@ -143,7 +155,7 @@ const sdpStereoHack = (sdp) => {
     };
     const opusPayload = getCodecPayloadType(sdpLines[opusIndex]);
     const pattern = new RegExp(`a=fmtp:${opusPayload}`);
-    const fmtpLineIndex = sdpLines.findIndex(s => pattern.test(s));
+    const fmtpLineIndex = sdpLines.findIndex((s) => pattern.test(s));
     if (fmtpLineIndex >= 0) {
         if (!/stereo=1;/.test(sdpLines[fmtpLineIndex])) {
             sdpLines[fmtpLineIndex] += '; stereo=1; sprop-stereo=1';
@@ -168,7 +180,7 @@ const sdpMediaOrderHack = (answer, localOffer) => {
     const answerAudioIndex = answerLines.findIndex(_isAudioLine);
     const answerVideoIndex = answerLines.findIndex(_isVideoLine);
     const audioLines = answerLines.slice(answerAudioIndex, answerVideoIndex);
-    const videoLines = answerLines.slice(answerVideoIndex, (answerLines.length - 1));
+    const videoLines = answerLines.slice(answerVideoIndex, answerLines.length - 1);
     const beginLines = answerLines.slice(0, answerAudioIndex);
     return [...beginLines, ...videoLines, ...audioLines, ''].join(endOfLine);
 };
@@ -185,9 +197,11 @@ const destructSubscribeResponse = (response) => {
         alreadySubscribed: [],
         unauthorized: [],
         unsubscribed: [],
-        notSubscribed: []
+        notSubscribed: [],
     };
-    Object.keys(tmp).forEach(k => { tmp[k] = response[`${k}Channels`] || []; });
+    Object.keys(tmp).forEach((k) => {
+        tmp[k] = response[`${k}Channels`] || [];
+    });
     return tmp;
 };
 const enableAudioTracks = (stream) => {
@@ -258,13 +272,15 @@ const filterIceServers = (servers, options = { disableUdpIceServers: false }) =>
     const filterNonTransportTCP = (urls) => {
         const transportParam = 'transport=tcp';
         if (urls instanceof Array) {
-            return urls.filter(url => url.includes(transportParam));
+            return urls.filter((url) => url.includes(transportParam));
         }
         else {
             return urls.includes(transportParam) ? urls : '';
         }
     };
-    return servers.map(server => (Object.assign(Object.assign({}, server), { urls: disableUdpIceServers ? filterNonTransportTCP(server.urls) : server.urls })));
+    return servers.map((server) => (Object.assign(Object.assign({}, server), { urls: disableUdpIceServers
+            ? filterNonTransportTCP(server.urls)
+            : server.urls })));
 };
 const sdpHasAudio = (sdp = '') => {
     return /m=audio/.test(sdp);
@@ -272,4 +288,4 @@ const sdpHasAudio = (sdp = '') => {
 const sdpHasVideo = (sdp = '') => {
     return /m=video/.test(sdp);
 };
-export { getUserMedia, getDevices, scanResolutions, getMediaConstraints, assureDeviceId, removeUnsupportedConstraints, checkDeviceIdConstraints, sdpStereoHack, sdpMediaOrderHack, sdpBitrateHack, checkSubscribeResponse, destructSubscribeResponse, enableAudioTracks, disableAudioTracks, toggleAudioTracks, enableVideoTracks, disableVideoTracks, toggleVideoTracks, filterIceServers, sdpHasAudio, sdpHasVideo };
+export { getUserMedia, getDevices, scanResolutions, getMediaConstraints, assureDeviceId, removeUnsupportedConstraints, checkDeviceIdConstraints, sdpStereoHack, sdpMediaOrderHack, sdpBitrateHack, checkSubscribeResponse, destructSubscribeResponse, enableAudioTracks, disableAudioTracks, toggleAudioTracks, enableVideoTracks, disableVideoTracks, toggleVideoTracks, filterIceServers, sdpHasAudio, sdpHasVideo, };

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

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

package/dist/esm/js/index.js

@@ -2,7 +2,7 @@ import Relay from './src/SignalWire';
 import Verto from './src/Verto';
 import { setAgentName } from '../common/src/messages/blade/Connect';
 import CantinaAuth from '../common/src/webrtc/CantinaAuth';
-export const VERSION = '1.4.2-rc.1';
+export const VERSION = '1.5.0';
 setAgentName(`JavaScript SDK/${VERSION}`);
 export { Relay, Verto, CantinaAuth };
 export * from '../common/src/util/interfaces';

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

@@ -15,11 +15,17 @@ export default class SignalWire extends BrowserSession {
     execute(message) {
         let msg = message;
         if (message instanceof BaseRequest) {
-            const params = { message: message.request };
+            const params = {
+                message: message.request,
+            };
             if (message.targetNodeId) {
                 params.node_id = message.targetNodeId;
             }
-            msg = new Execute({ protocol: this.relayProtocol, method: 'message', params });
+            msg = new Execute({
+                protocol: this.relayProtocol,
+                method: 'message',
+                params,
+            });
         }
         return super.execute(msg);
     }