@formant/realtime-sdk 0.0.15 → 0.0.17

package/dist/rtc-client/RtcClientV1.d.ts

@@ -0,0 +1,51 @@
+import { IRtcPeer } from "../model/IRtcPeer";
+import { RtcConnectionStatus } from "../model/RtcConnectionStatus";
+import { Timestamp } from "../model/Timestamp";
+import { Uuid } from "../model/Uuid";
+import { IRtcClientConfigurationV1 } from "./models-v1/IRtcClientConfigurationV1";
+import { IIceMode } from "./models/IIceMode";
+import { IRtcSendConfiguration } from "./models/IRtcSendConfiguration";
+import { IRtcStreamMessage } from "./models/IRtcStreamMessage";
+import { IStreamControl } from "./models/IStreamControl";
+/**
+ * RtcClient to be used by browsers.
+ * Interacts with signaling API v1.
+ */
+export declare class RtcClientV1 {
+    private config;
+    private localPeer;
+    private updateInterval;
+    private connections;
+    private connectingSessions;
+    constructor(config: IRtcClientConfigurationV1);
+    send(peerId: Uuid, message: IRtcStreamMessage, config: IRtcSendConfiguration): void;
+    controlRemoteStream(peerId: Uuid, streamControl: IStreamControl): void;
+    /**
+     * Connects to a peer given its id.
+     * Returns the id of the session, if one is created.
+     */
+    connect(peerId: Uuid): Promise<Uuid | undefined>;
+    getConnectionStatus(peerId: Uuid): RtcConnectionStatus;
+    getIceMode(peerId: Uuid): IIceMode | undefined;
+    disconnect(peerId: Uuid): Promise<void>;
+    getLocalPeer(): Promise<IRtcPeer>;
+    getPeers(): Promise<IRtcPeer[]>;
+    getPing(peerId: Uuid): number | undefined;
+    getLastMessageTimestamp(remotePeerId: Uuid): Timestamp | undefined;
+    shutdown(): Promise<void>;
+    private closeConnection;
+    private getSessions;
+    private createPeer;
+    private createRTCPeerConnection;
+    private closeConnections;
+    private reset;
+    private getActiveConnection;
+    private update;
+    private handleSessions;
+    private syncConnectionsAndSessions;
+    private maintainConnection;
+    private connectToSession;
+    private setupHandlers;
+    private consumeSignals;
+    private sendSignal;
+}

package/dist/rtc-client/RtcConnection.d.ts

@@ -1,6 +1,7 @@
 import { Timestamp } from "../model/Timestamp";
 import { Uuid } from "../model/Uuid";
 import { Signal } from "../protos/api/signaling/v1/signaling_pb";
+import { IPingInfo } from "./models/IPingInfo";
 import { IRtcConnectionConfiguration } from "./models/IRtcConnectionConfiguration";
 import { IRtcConnectionStatsInfo } from "./models/IRtcConnectionStatsInfo";
 import { IRtcSendConfiguration } from "./models/IRtcSendConfiguration";
@@ -14,6 +15,8 @@ export declare class RtcConnection {
     private readonly connectTimeoutMs;
     private readonly iceGatheringTimeoutMs;
     private readonly pingUpdateTimeoutMs;
+    private readonly pingV2UpdateTimeoutMs;
+    private readonly pingV2MetricsGatherTimeoutMs;
     private readonly streamsInfoUpdateTimeoutMs;
     private readonly reassemblyTimeoutMs;
     private readonly reassemblyTableCleanupMs;
@@ -28,6 +31,8 @@ export declare class RtcConnection {
     private reassemblyTableLastTimestamp;
     private reassemblyTableCleanupTimeout;
     private pingUpdateTimeout;
+    private pingV2UpdateTimeout;
+    private pingV2MetricsGatherTimeout;
     private streamsInfoUpdateTimeout;
     private heartbeatTimeout;
     private pingTimeMs;
@@ -36,6 +41,8 @@ export declare class RtcConnection {
     private closeCalled;
     private gotOffer;
     private hasIceCandidate;
+    private pingV2Map;
+    private pingInfo;
     constructor(peerConnection: RTCPeerConnection, config: IRtcConnectionConfiguration, dataChannelNotifier: (channel: RTCDataChannel) => void);
     handleSignal(signal: Signal): Promise<Signal | undefined>;
     /**
@@ -51,6 +58,7 @@ export declare class RtcConnection {
     isReady(): boolean;
     close(): Promise<void>;
     getPing(): number | undefined;
+    getPingInfo(): IPingInfo | undefined;
     getLastMessageTimestamp(): Timestamp | undefined;
     getSessionCreatedTimestamp(): Timestamp | undefined;
     setSessionCreatedTimestamp(sessionCreatedTimestamp: Timestamp): void;
@@ -78,4 +86,6 @@ export declare class RtcConnection {
     private handleSystemMessage;
     private sendSystemMessage;
     private isLatestMessage;
+    private sendPingV2;
+    private gatherPingV2Metrics;
 }

package/dist/rtc-client/RtcConnectionV1.d.ts

@@ -0,0 +1,72 @@
+import { IRtcSignal } from "../model/IRtcSignal";
+import { IRtcConnectionConfigurationV1 } from "./models-v1/IRtcConnectionConfigurationV1";
+import { IIceMode } from "./models/IIceMode";
+import { IRtcSendConfiguration } from "./models/IRtcSendConfiguration";
+import { IRtcStreamMessage } from "./models/IRtcStreamMessage";
+import { IStreamControl } from "./models/IStreamControl";
+export declare class RtcConnectionV1 {
+    peerConnection: RTCPeerConnection;
+    private config;
+    iceMode?: IIceMode;
+    private readonly connectTimeoutMs;
+    private readonly gatherIceTimeoutMs;
+    private readonly pingUpdateTimeoutMs;
+    private latestTtlStreamChannel?;
+    private reliableStreamChannel?;
+    private latestReliableStreamChannel?;
+    private latestTryOnceStreamChannel?;
+    private streamLatestTimestamp;
+    private pingUpdateTimeout;
+    private pingTimeMs;
+    private lastMessageTimestamp;
+    private connectTimeout;
+    private gatherIceTimeout;
+    private sessionMetrics;
+    private closeCalled;
+    private connectCalled;
+    private sentOffer;
+    private receivedIceCandidate;
+    constructor(peerConnection: RTCPeerConnection, config: IRtcConnectionConfigurationV1);
+    connect(): Promise<void>;
+    handleSignal(signal: IRtcSignal): Promise<void>;
+    /**
+     * Sends a message to the remote peer.
+     */
+    send(message: IRtcStreamMessage, config: IRtcSendConfiguration): void;
+    controlRemoteStream(streamControl: IStreamControl): void;
+    isActive(): boolean;
+    /**
+     * Checks that the peerConnection is connected
+     * and all data channels exist and are open
+     */
+    isReady(): boolean;
+    /**
+     * Checks that the peerConnection is closed and all
+     * existing data channels are closed
+     */
+    isClosed(): boolean;
+    /**
+     * Checks that either the peerConnection is inactive
+     * or at least one of the the data channels exists and is inactive
+     */
+    needsClosing(): boolean | undefined;
+    close(): Promise<void>;
+    getPing(): number | undefined;
+    getLastMessageTimestamp(): number | undefined;
+    getSessionId(): string;
+    getRemotePeer(): import("../model/IRtcPeer").IRtcPeer;
+    private initializeChannels;
+    private sendOffer;
+    private getChannelFromLabel;
+    private sendOnChannel;
+    private channelNotRecognized;
+    private setupChannel;
+    /**
+     * Handles system messages (e.g., ping/pong).
+     * Returns true if the message is a system message.
+     */
+    private handleSystemMessage;
+    private sendSystemMessage;
+    private hasCapabilities;
+    private isLatestMessage;
+}

package/dist/rtc-client/RtcSessionMetricsV1.d.ts

@@ -0,0 +1,12 @@
+import { IRtcStreamMessage } from "./models/IRtcStreamMessage";
+import { RtcConnectionV1 } from "./RtcConnectionV1";
+export declare class RtcSessionMetricsV1 {
+    private sessionId;
+    private connection;
+    private sentMessagesCounts;
+    private receivedMessagesCounts;
+    constructor(sessionId: string, connection: RtcConnectionV1);
+    incrementMessageSent(message: IRtcStreamMessage): void;
+    incrementMessageReceived(message: IRtcStreamMessage): void;
+    uploadMetrics(): Promise<void>;
+}

package/dist/rtc-client/gatherPingMetrics.d.ts

@@ -0,0 +1,17 @@
+import { Timestamp } from "../model/Timestamp";
+import { Uuid } from "../model/Uuid";
+import { IPingInfo } from "./models/IPingInfo";
+export interface IPing {
+    sent: Timestamp;
+}
+export interface IPingPong {
+    sent: Timestamp;
+    received: Timestamp;
+}
+export declare type PingValue = IPing | IPingPong;
+export declare type PingMap = Map<Uuid, PingValue>;
+interface IGatherPingV2MetricsOptions {
+    temporalNow?: number;
+}
+export declare function gatherPingV2Metrics(pingMap: PingMap, options?: IGatherPingV2MetricsOptions): IPingInfo | null;
+export {};

package/dist/rtc-client/models/IPingInfo.d.ts

@@ -0,0 +1,10 @@
+export interface IPingInfo {
+    pingsSent: number;
+    pongsReceived: number;
+    average: number;
+    standardDeviation: number;
+    jitter: number;
+    min: number;
+    max: number;
+    loss: number;
+}

package/dist/rtc-client/models/IPingPayload.d.ts

@@ -0,0 +1,6 @@
+import { Timestamp } from "../../model/Timestamp";
+import { Uuid } from "../../model/Uuid";
+export interface IPingPayload {
+    timestamp: Timestamp;
+    id: Uuid;
+}

package/dist/rtc-client/models/IRtcClientConfiguration.d.ts

@@ -1,18 +1,18 @@
 import { Timestamp } from "../../model/Timestamp";
 import { Uuid } from "../../model/Uuid";
 import { SignalingPromiseClient } from "../../protos/api/signaling/v1/signaling_grpc_web_pb";
+import { SessionType } from "../../protos/api/signaling/v1/signaling_pb";
 import { IRtcStreamMessage } from "./IRtcStreamMessage";
 export declare type IRtcClientConfiguration = {
-    lanOnlyMode: true;
     receive: (peerId: Uuid, message: IRtcStreamMessage) => void;
     onStreamsInfoUpdate?: (peerId: Uuid, timestamp: Timestamp) => void;
     alternateRTCPeerConnection?: typeof RTCPeerConnection;
+    sessionType?: SessionType;
+} & ({
+    lanOnlyMode: true;
 } | {
     lanOnlyMode?: false;
-    receive: (peerId: Uuid, message: IRtcStreamMessage) => void;
     getToken: () => Promise<string>;
     signalingClient: SignalingPromiseClient;
-    onStreamsInfoUpdate?: (peerId: Uuid, timestamp: Timestamp) => void;
-    alternateRTCPeerConnection?: typeof RTCPeerConnection;
     track?: (event: string, properties?: object) => void;
-};
+});

package/dist/rtc-client/models/IRtcStreamPayload.d.ts

@@ -10,6 +10,7 @@ import { IPoseWithCovariance } from "../../model/IPoseWithCovariance";
 import { ITransform } from "../../model/ITransform";
 import { ITwist } from "../../model/ITwist";
 import { Timestamp } from "../../model/Timestamp";
+import { IPingPayload } from "./IPingPayload";
 import { IRtcAgentInfo } from "./IRtcAgentInfo";
 import { IRtcPointCloud } from "./IRtcPointCloud";
 import { IRtcStreamsInfo } from "./IRtcStreamsInfo";
@@ -17,6 +18,8 @@ import { IStreamControl } from "./IStreamControl";
 export interface IRtcStreamPayload {
     ping?: Timestamp;
     pong?: Timestamp;
+    pingV2?: IPingPayload;
+    pongV2?: IPingPayload;
     streamControl?: IStreamControl;
     streamsInfo?: IRtcStreamsInfo;
     agentInfo?: IRtcAgentInfo;

package/dist/rtc-client/models-v1/IRtcClientConfigurationV1.d.ts

@@ -0,0 +1,11 @@
+import { RtcSignalingClient } from "../../client/RtcSignalingClient";
+import { IRtcCapabilitySet } from "../../model/IRtcCapabilitySet";
+import { Uuid } from "../../model/Uuid";
+import { IRtcStreamMessage } from "../models/IRtcStreamMessage";
+export interface IRtcClientConfigurationV1 {
+    signalingClient: RtcSignalingClient;
+    getToken: () => Promise<string>;
+    receive: (peerId: Uuid, message: IRtcStreamMessage) => void;
+    alternateRTCPeerConnection?: typeof RTCPeerConnection;
+    capabilitySet?: IRtcCapabilitySet;
+}

package/dist/rtc-client/models-v1/IRtcConnectionConfigurationV1.d.ts

@@ -0,0 +1,12 @@
+import { IRtcPeer } from "../../model/IRtcPeer";
+import { IRtcSignal } from "../../model/IRtcSignal";
+import { Uuid } from "../../model/Uuid";
+import { IRtcStreamMessage } from "../models/IRtcStreamMessage";
+export interface IRtcConnectionConfigurationV1 {
+    sessionId: Uuid;
+    localPeer: IRtcPeer;
+    remotePeer: IRtcPeer;
+    isOffer: boolean;
+    sendSignal: (signal: IRtcSignal) => Promise<void>;
+    receive: (peerId: Uuid, message: IRtcStreamMessage) => void;
+}

package/dist/rtc-client/utils/encodeStreamId.d.ts

@@ -0,0 +1,3 @@
+import { IRtcStream } from "../../model/IRtcStream";
+export declare function encodeStreamId({ entityId, streamName, streamType }: IRtcStream): string;
+export declare function decodeStreamId(streamId: string): IRtcStream;

package/dist/rtc-client/utils/streamIsEqual.d.ts

@@ -0,0 +1,2 @@
+import { IRtcStream } from "../../model/IRtcStream";
+export declare function streamIsEqual(stream1: IRtcStream, stream2: IRtcStream): boolean;

package/dist/ui/utils/browser.d.ts

@@ -0,0 +1,2 @@
+export declare type BrowserType = "Firefox" | "Chrome" | "Edge" | "Safari" | "IE" | "Other";
+export declare function browser(): BrowserType;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@formant/realtime-sdk",
-    "version": "0.0.15",
+    "version": "0.0.17",
     "license": "MIT",
     "main": "./dist/index.js",
     "types": "./dist/realtime-sdk/src/index.d.ts",
@@ -10,16 +10,22 @@
     "scripts": {
         "clean": "rm -rf dist",
         "compile": "tsc",
-        "build": "yarn make-protos && env $(cat src/config/production.env) webpack",
+        "build": "yarn make-protos && env $(grep -v '^#' src/config/production.env) webpack",
         "postbuild": "tsc --emitDeclarationOnly --declaration --declarationDir ./dist --skipLibCheck && tsc-alias",
         "prepublishOnly": "yarn clean && yarn build",
         "make-protos": "cd ../../../ && make protos && cd -"
     },
     "dependencies": {
-        "google-protobuf": "3.17.3",
-        "grpc-web": "1.2.1"
+        "env-var": "^7.3.0",
+        "google-protobuf": "^3.17.3",
+        "grpc-web": "^1.2.1"
     },
     "devDependencies": {
+        "@formant/client": "*",
+        "@formant/common": "*",
+        "@formant/model": "*",
+        "@formant/protos": "*",
+        "@formant/rtc-client": "*",
         "circular-dependency-plugin": "^5.2.2",
         "copy-webpack-plugin": "^6.4.1",
         "file-loader": "^5.1.0",

package/dist/common/LoggerReporter.d.ts

@@ -1,9 +0,0 @@
-import { IStat } from "../model/IStat";
-import { IStatsReporter } from "../model/IStatsReporter";
-export declare class LoggerReporter implements IStatsReporter {
-    private message;
-    constructor(message: string);
-    send(values: {
-        [key: string]: IStat;
-    }): Promise<void>;
-}

package/dist/model/IStatsReporter.d.ts

@@ -1,6 +0,0 @@
-import { IStat } from "../model/IStat";
-export interface IStatsReporter {
-    send(values: {
-        [key: string]: IStat;
-    }): Promise<void>;
-}

package/dist/rtc-client/models/IRtcConnectConfiguration.d.ts

@@ -1,8 +0,0 @@
-import { RtcIceServerProtocol } from "../../model/RtcIceServerProtocol";
-import { RtcIceTransportPolicy } from "../../model/RtcIceTransportPolicy";
-import { SessionType } from "../../protos/api/signaling/v1/signaling_pb";
-export interface IRtcConnectConfiguration {
-    rtcIceServerProtocol?: RtcIceServerProtocol;
-    rtcIceTransportPolicies?: RtcIceTransportPolicy[];
-    sessionType?: SessionType;
-}

package/dist/rtc-client/utils/getStreamId.d.ts

@@ -1,2 +0,0 @@
-import { IRtcStream } from "../../model/IRtcStream";
-export declare function getStreamId({ entityId, streamName, streamType }: IRtcStream): string;