@100mslive/hms-video-store 0.14.7 → 0.14.8-alpha.0

package/dist/interfaces/room.d.ts

@@ -35,7 +35,7 @@ export interface HMSRoom {
     isVBEnabled?: boolean;
     effectsKey?: string;
     isHipaaEnabled?: boolean;
-    isNoiseCancellationEnabled?: boolean;
+    readonly isNoiseCancellationEnabled?: boolean;
     transcriptions?: HMSTranscriptionInfo[];
 }
 export interface HMSRecording {

package/dist/interfaces/webrtc-stats.d.ts

@@ -117,9 +117,46 @@ export interface HMSRemoteTrackStats extends BaseTrackStats, MissingInboundStats
 }
 export interface HMSTrackStats extends HMSLocalTrackStats, HMSRemoteTrackStats {
 }
+/**
+ * `RTCIceCandidateStats` is absent from TS's DOM lib, and `relayProtocol`/`networkType`/`url`
+ * are reported by browsers but not typed anywhere.
+ * Ref: https://www.w3.org/TR/webrtc-stats/#icecandidate-dict*
+ */
+export interface HMSIceCandidateStats extends RTCStats {
+    transportId?: string;
+    address?: string;
+    port?: number;
+    protocol?: IceProtocol;
+    candidateType?: RTCIceCandidateType;
+    priority?: number;
+    url?: string;
+    /**
+     * Transport used to reach the TURN server. Only set on candidates obtained through a relay,
+     * which makes it — not `candidateType` — the proof that a path is relayed: a candidate can
+     * carry `relayProtocol` while its `candidateType` is `prflx`, when the peer-reflexive address
+     * was learnt over the relay.
+     */
+    relayProtocol?: IceProtocol | 'tls';
+    networkType?: string;
+}
+declare type IceProtocol = 'udp' | 'tcp';
+/**
+ * How the local peer is actually reaching the SFU: a direct path (`host`/`srflx`/`prflx`) or
+ * a TURN relay, with the transport used to reach the TURN server.
+ */
+export declare type HMSConnectionType = RTCIceCandidateType | `relay(${IceProtocol | 'tls'})`;
+/**
+ * The active ICE candidate pair of a peer connection, along with the two candidates it points
+ * at — resolved from `localCandidateId`/`remoteCandidateId` against the same stats report, since
+ * those ids are only meaningful within the report they came from.
+ */
+export declare type HMSConnectionStats = RTCIceCandidatePairStats & {
+    bitrate: number;
+    localCandidate?: HMSIceCandidateStats;
+    remoteCandidate?: HMSIceCandidateStats;
+};
 export interface HMSPeerStats {
-    publish?: RTCIceCandidatePairStats & {
-        bitrate: number;
+    publish?: HMSConnectionStats & {
         /**
          * Sum of `bytesSent` across active outbound-rtp streams at the time the stat was taken.
          * Used internally to derive `bitrate` on the next sample so the value only reflects
@@ -127,8 +164,7 @@ export interface HMSPeerStats {
          */
         outboundRtpBytesSent?: number;
     };
-    subscribe?: RTCIceCandidatePairStats & {
-        bitrate: number;
+    subscribe?: HMSConnectionStats & {
         packetsLost: number;
         packetsLostRate: number;
         jitter: number;

package/dist/rtc-stats/utils.d.ts

@@ -1,12 +1,17 @@
 import { EventBus } from '../events/EventBus';
-import { HMSPeerStats, HMSTrackStats, PeerConnectionType } from '../interfaces/webrtc-stats';
+import { HMSConnectionStats, HMSConnectionType, HMSIceCandidateStats, HMSPeerStats, HMSTrackStats, PeerConnectionType } from '../interfaces/webrtc-stats';
 import { HMSLocalTrack, HMSRemoteTrack } from '../media/tracks';
 export declare const getLocalTrackStats: (eventBus: EventBus, track: HMSLocalTrack, peerName?: string, prevTrackStats?: Record<string, HMSTrackStats>) => Promise<Record<string, HMSTrackStats> | undefined>;
 export declare const getTrackStats: (eventBus: EventBus, track: HMSRemoteTrack, peerName?: string, prevTrackStats?: HMSTrackStats) => Promise<HMSTrackStats | undefined>;
 export declare const sumOutboundRtpBytesSent: (report?: RTCStatsReport) => number;
-export declare const getLocalPeerStatsFromReport: (type: PeerConnectionType, report?: RTCStatsReport, prevStats?: HMSPeerStats) => (RTCIceCandidatePairStats & {
-    bitrate: number;
-    outboundRtpBytesSent?: number | undefined;
+/**
+ * Whether the connection runs over a TURN relay (and over which transport) or directly.
+ */
+export declare const getConnectionType: (stats?: {
+    localCandidate?: HMSIceCandidateStats;
+}) => HMSConnectionType | undefined;
+export declare const getLocalPeerStatsFromReport: (type: PeerConnectionType, report?: RTCStatsReport, prevStats?: HMSPeerStats) => (HMSConnectionStats & {
+    outboundRtpBytesSent?: number;
 }) | undefined;
 export declare const getActiveCandidatePairFromReport: (report?: RTCStatsReport) => RTCIceCandidatePairStats | undefined;
 export declare const getPacketsLostAndJitterFromReport: (report?: RTCStatsReport) => {

package/dist/sdk/models/HMSRoom.d.ts

@@ -19,10 +19,26 @@ export default class Room implements HMSRoom {
     isVBEnabled?: boolean;
     effectsKey?: string;
     isHipaaEnabled?: boolean;
-    isNoiseCancellationEnabled?: boolean;
+    /**
+     * Raw `noiseCancellation` feature flag from /init. Written only by HMSTransport
+     * on every connect, including reconnects. Never AND it here — see the derived
+     * getter below.
+     */
+    isNoiseCancellationEnabledFromInit: boolean;
+    /**
+     * The template policy's `noiseCancellation.enabled`. Written only by Store when
+     * policy arrives. Absent policy key means not configured, which means false.
+     */
+    isNoiseCancellationEnabledFromPolicy: boolean;
     translationConfig?: Record<HMSTranscriptionMode, {
         enabled: boolean;
         roleLanguages?: Record<string, string>;
     }>;
+    /**
+     * Noise cancellation is available only when the account's feature flag and the
+     * template policy both allow it. Derived, never stored, so that a reconnect
+     * re-writing the init flag cannot clobber the template's decision.
+     */
+    get isNoiseCancellationEnabled(): boolean;
     constructor(id: string);
 }

package/dist/webrtc-stats/selectors.d.ts

@@ -8,6 +8,8 @@ export declare const selectHMSStats: {
     subscribeBitrate: import("reselect").OutputSelector<HMSStatsStore, number | undefined, (res: import("../internal").HMSPeerStats | undefined) => number | undefined>;
     availablePublishBitrate: import("reselect").OutputSelector<HMSStatsStore, number | undefined, (res: import("../internal").HMSPeerStats | undefined) => number | undefined>;
     availableSubscribeBitrate: import("reselect").OutputSelector<HMSStatsStore, number | undefined, (res: import("../internal").HMSPeerStats | undefined) => number | undefined>;
+    publishConnectionType: import("reselect").OutputSelector<HMSStatsStore, import("../internal").HMSConnectionType | undefined, (res: import("../internal").HMSPeerStats | undefined) => import("../internal").HMSConnectionType | undefined>;
+    subscribeConnectionType: import("reselect").OutputSelector<HMSStatsStore, import("../internal").HMSConnectionType | undefined, (res: import("../internal").HMSPeerStats | undefined) => import("../internal").HMSConnectionType | undefined>;
     totalBytesSent: import("reselect").OutputSelector<HMSStatsStore, number | undefined, (res: import("../internal").HMSPeerStats | undefined) => number | undefined>;
     totalBytesReceived: import("reselect").OutputSelector<HMSStatsStore, number | undefined, (res: import("../internal").HMSPeerStats | undefined) => number | undefined>;
     peerStatsByID: (id?: string | undefined) => import("../selectors/common").StoreSelector<HMSStatsStore, import("../internal").HMSPeerStats | undefined>;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.14.7",
+  "version": "0.14.8-alpha.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -72,5 +72,5 @@
     "conferencing",
     "100ms"
   ],
-  "gitHead": "0bea9e63f6501bae6109370f02b97e493e0c84c7"
+  "gitHead": "a74b883e772f7992107f8c34b5a205b1ecfdd378"
 }