@simplito/privmx-webendpoint 2.6.5 → 2.7.1

package/dist/webStreams/WebRtcInterfaceImpl.js

@@ -0,0 +1,85 @@
+"use strict";
+/*!
+PrivMX Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebRtcInterfaceImpl = void 0;
+class WebRtcInterfaceImpl {
+    webRtcClient;
+    constructor(webRtcClient) {
+        this.webRtcClient = webRtcClient;
+    }
+    methodsMap = {
+        createOfferAndSetLocalDescription: this.createOfferAndSetLocalDescription,
+        createAnswerAndSetDescriptions: this.createAnswerAndSetDescriptions,
+        setAnswerAndSetRemoteDescription: this.setAnswerAndSetRemoteDescription,
+        updateSessionId: this.updateSessionId,
+        close: this.close,
+        updateKeys: this.updateKeys,
+    };
+    isMainThread() {
+        return typeof window !== "undefined";
+    }
+    getClient() {
+        if (!this.webRtcClient) {
+            throw new Error("WebRtcClient not initialized. Aborting...");
+        }
+        return this.webRtcClient;
+    }
+    async methodCall(name, params) {
+        if (this.methodsMap[name]) {
+            const method = this.methodsMap[name];
+            if (typeof method === "function") {
+                return this.methodsMap[name].call(this, params);
+            }
+        }
+        throw new Error(`Method '${name}' is not implemented.`);
+    }
+    async createOfferAndSetLocalDescription(model) {
+        const peerConnection = this.getClient()
+            .getConnectionManager()
+            .getConnectionWithSession(model.roomId, "publisher").pc;
+        const offer = await peerConnection.createOffer();
+        await peerConnection.setLocalDescription(offer);
+        return offer.sdp; // sdp
+    }
+    async createAnswerAndSetDescriptions(model) {
+        const offer = { sdp: model.sdp, type: model.type };
+        await this.getClient().onSubscriptionUpdated(model.roomId, offer);
+        return this.webRtcClient.lastProcessedAnswer[model.roomId].sdp;
+    }
+    async setAnswerAndSetRemoteDescription(model) {
+        const janusSession = this.getClient()
+            .getConnectionManager()
+            .getConnectionWithSession(model.roomId, "publisher");
+        if (!("pc" in janusSession)) {
+            throw new Error("WebRtcInterfaceImpl: No peerConnection available on setAnswerAndSetRemoteDescription");
+        }
+        const peerConnection = janusSession.pc;
+        await peerConnection.setRemoteDescription(new RTCSessionDescription({ sdp: model.sdp, type: model.type }));
+    }
+    async close(roomId) {
+        this.getClient()
+            .getConnectionManager()
+            .closePeerConnectionBySessionIfExists(roomId, "subscriber");
+        this.getClient()
+            .getConnectionManager()
+            .closePeerConnectionBySessionIfExists(roomId, "publisher");
+    }
+    async updateKeys(model) {
+        return this.getClient().updateKeys(model.streamRoomId, model.keys);
+    }
+    async updateSessionId(streamRoomId, sessionId, connectionType) {
+        this.getClient()
+            .getConnectionManager()
+            .updateSessionForConnection(streamRoomId, connectionType, sessionId);
+    }
+}
+exports.WebRtcInterfaceImpl = WebRtcInterfaceImpl;

package/dist/webStreams/WebWorkerHelper copy.js

@@ -0,0 +1,17 @@
+"use strict";
+// import { EncKey } from "./WebRtcClientTypes";
+// export class WebWorker {
+//     worker: Worker | undefined;
+//     constructor(private encKey: EncKey) {
+//       // this.worker = new Worker(new URL("./worker/worker.ts", import.meta.url), {name: "worker"});
+//       this.worker = new Worker(new URL("worker.js", import.meta.url), {name: "worker"});
+//       this.worker.onerror = e => console.error(e);
+//       this.worker.postMessage({
+//           operation: 'initialize',
+//           key: encKey.key, iv: encKey.iv
+//       });
+//     }
+//     getWorker() {
+//       return this.worker;
+//     }
+// }

package/dist/webStreams/WebWorkerHelper.d.ts

@@ -0,0 +1,18 @@
+import { Key } from "../Types";
+export interface FrameInfo {
+    rms: number;
+    kind: "audio";
+    receiverId: number;
+    publisherId: number;
+}
+export declare class WebWorker {
+    private assetsDir;
+    private onFrame;
+    worker: Worker | undefined;
+    constructor(assetsDir: string, onFrame: (frameInfo: FrameInfo) => void);
+    init_e2ee(): Promise<void>;
+    getWorker(): Worker;
+    setKeys(keys: Key[]): void;
+    createWorkerFromFunction(workerFunction: Function): Worker;
+    createWorkerFromScript(scriptUrl: string): Promise<Worker>;
+}

package/dist/webStreams/WebWorkerHelper.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebWorker = void 0;
+class WebWorker {
+    assetsDir;
+    onFrame;
+    worker;
+    constructor(assetsDir, onFrame) {
+        this.assetsDir = assetsDir;
+        this.onFrame = onFrame;
+    }
+    async init_e2ee() {
+        this.worker = new Worker(this.assetsDir + "/e2ee-worker.js");
+        this.worker.onmessage = (event) => {
+            try {
+                if (event.data.type === "rms") {
+                    if (this.onFrame !== undefined && typeof this.onFrame === "function") {
+                        this.onFrame({
+                            rms: event.data.rms,
+                            kind: "audio",
+                            receiverId: event.data.receiverId,
+                            publisherId: event.data.publisherId,
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                console.error("[Worker]: invalid event");
+            }
+        };
+        this.worker.onerror = (e) => console.error(e);
+        this.worker.postMessage({
+            operation: "initialize",
+        });
+    }
+    getWorker() {
+        return this.worker;
+    }
+    setKeys(keys) {
+        if (!this.worker) {
+            console.warn("Cannot pass keys to e2ee worker as it is not initialized yet.");
+            return;
+        }
+        this.worker.postMessage({
+            operation: "setKeys",
+            keys,
+        });
+    }
+    createWorkerFromFunction(workerFunction) {
+        const blob = new Blob([`(${workerFunction.toString()})()`], {
+            type: "application/javascript",
+        });
+        return new Worker(URL.createObjectURL(blob));
+    }
+    async createWorkerFromScript(scriptUrl) {
+        const scriptContent = await fetch(scriptUrl).then((r) => r.text());
+        const blob = new Blob([scriptContent], { type: "application/javascript" });
+        const workerUrl = URL.createObjectURL(blob);
+        const worker = new Worker(workerUrl);
+        return worker;
+    }
+}
+exports.WebWorker = WebWorker;
+// function workerScript() {
+//     self.onmessage = WorkerSpec.onmessage;
+// }
+function workerScript() {
+    return "";
+}

package/dist/webStreams/audio/ActiveSpeakerDetector.d.ts

@@ -0,0 +1,38 @@
+export declare const DEFAULTS: {
+    rmsEmaAlpha: number;
+    noiseEmaAlpha: number;
+    thresholdOffset: number;
+    activityWindowMs: number;
+    holdMs: number;
+};
+type SpeakerId = number;
+interface FrameInput {
+    id: SpeakerId;
+    rms: number;
+    timestamp: number;
+}
+export interface SpeakerState {
+    streamId: number;
+    emaRms: number;
+    noiseFloor: number;
+    lastAboveThresholdTs: number;
+    activeSince: number;
+    active: boolean;
+}
+interface ActiveSpeakerDetectorOptions {
+    rmsEmaAlpha: number;
+    noiseEmaAlpha: number;
+    thresholdOffset: number;
+    activityWindowMs: number;
+    holdMs: number;
+}
+export declare class ActiveSpeakerDetector {
+    private opts;
+    private speakers;
+    private activeSpeaker;
+    constructor(opts: ActiveSpeakerDetectorOptions);
+    onFrame({ id, rms, timestamp }: FrameInput): SpeakerState[];
+    private selectActiveSpeakers;
+    private getOrCreateState;
+}
+export {};

package/dist/webStreams/audio/ActiveSpeakerDetector.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActiveSpeakerDetector = exports.DEFAULTS = void 0;
+exports.DEFAULTS = {
+    rmsEmaAlpha: 0.2, // szybka reakcja na mowę
+    noiseEmaAlpha: 0.02, // wolna adaptacja tła
+    thresholdOffset: 6, // dB (jeśli RMS w dB)
+    activityWindowMs: 400,
+    holdMs: 200,
+};
+class ActiveSpeakerDetector {
+    opts;
+    speakers = new Map();
+    activeSpeaker = null;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    onFrame({ id, rms, timestamp }) {
+        const state = this.getOrCreateState(id, rms);
+        state.emaRms = this.opts.rmsEmaAlpha * rms + (1 - this.opts.rmsEmaAlpha) * state.emaRms;
+        if (state.emaRms < state.noiseFloor + this.opts.thresholdOffset) {
+            state.noiseFloor =
+                this.opts.noiseEmaAlpha * state.emaRms +
+                    (1 - this.opts.noiseEmaAlpha) * state.noiseFloor;
+        }
+        const adaptiveThreshold = state.noiseFloor + this.opts.thresholdOffset;
+        if (state.emaRms >= adaptiveThreshold) {
+            state.lastAboveThresholdTs = timestamp;
+            state.activeSince = timestamp;
+            state.active = true;
+        }
+        else {
+            state.active = false;
+            state.activeSince = 0;
+        }
+        return this.selectActiveSpeakers(timestamp);
+    }
+    selectActiveSpeakers(now) {
+        let bestId = null;
+        let bestRms = -Infinity;
+        for (const [id, state] of this.speakers.entries()) {
+            state.active =
+                now - state.lastAboveThresholdTs <= this.opts.activityWindowMs &&
+                    now - state.activeSince < this.opts.holdMs;
+        }
+        return Array.from(this.speakers.values());
+    }
+    getOrCreateState(id, rms) {
+        let state = this.speakers.get(id);
+        if (!state) {
+            state = {
+                streamId: id,
+                emaRms: rms,
+                noiseFloor: rms,
+                lastAboveThresholdTs: -Infinity,
+                active: false,
+                activeSince: 0,
+            };
+            this.speakers.set(id, state);
+        }
+        return state;
+    }
+}
+exports.ActiveSpeakerDetector = ActiveSpeakerDetector;

package/dist/webStreams/audio/LocalAudioLevelMeter.d.ts

@@ -0,0 +1,12 @@
+export declare class LocalAudioLevelMeter {
+    private track;
+    private onLevel;
+    private ctx;
+    private node;
+    private source;
+    private keepAliveGain;
+    private stopped;
+    constructor(track: MediaStreamTrack, onLevel: (rmsDb: number) => void);
+    init(workletUrl: string): Promise<void>;
+    stop(): void;
+}

package/dist/webStreams/audio/LocalAudioLevelMeter.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalAudioLevelMeter = void 0;
+class LocalAudioLevelMeter {
+    track;
+    onLevel;
+    ctx;
+    node;
+    source;
+    keepAliveGain;
+    stopped = false;
+    constructor(track, onLevel) {
+        this.track = track;
+        this.onLevel = onLevel;
+    }
+    async init(workletUrl) {
+        const candidateSampleRates = [];
+        try {
+            const settings = this.track.getSettings?.();
+            if (typeof settings?.sampleRate === "number") {
+                candidateSampleRates.push(settings.sampleRate);
+            }
+        }
+        catch {
+            // ignore
+        }
+        candidateSampleRates.push(undefined);
+        let lastErr;
+        for (const sampleRate of candidateSampleRates) {
+            if (this.stopped) {
+                throw new Error("LocalAudioLevelMeter stopped during init");
+            }
+            try {
+                this.ctx = sampleRate ? new AudioContext({ sampleRate }) : new AudioContext();
+                await this.ctx.audioWorklet.addModule(workletUrl);
+                try {
+                    await this.ctx.resume();
+                }
+                catch {
+                    // ignore (can be blocked until user gesture)
+                }
+                this.source = this.ctx.createMediaStreamSource(new MediaStream([this.track]));
+                this.node = new AudioWorkletNode(this.ctx, "rms-processor");
+                this.node.port.onmessage = (e) => this.onLevel(e.data.rmsDb);
+                this.keepAliveGain = this.ctx.createGain();
+                this.keepAliveGain.gain.value = 0;
+                this.source.connect(this.node);
+                this.node.connect(this.keepAliveGain);
+                this.keepAliveGain.connect(this.ctx.destination);
+                lastErr = undefined;
+                break;
+            }
+            catch (e) {
+                lastErr = e;
+                try {
+                    this.ctx?.close();
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        if (lastErr) {
+            throw lastErr;
+        }
+    }
+    stop() {
+        this.stopped = true;
+        try {
+            this.node?.port?.close();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            this.source?.disconnect();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            this.node?.disconnect();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            this.keepAliveGain?.disconnect();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            this.ctx?.close();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+exports.LocalAudioLevelMeter = LocalAudioLevelMeter;

package/dist/webStreams/types/ApiTypes.d.ts

@@ -0,0 +1,74 @@
+import { StreamHandle } from "../../Types";
+import * as MediaServerTypes from "./MediaServerWebSocketApiTypes";
+export interface UserWithPubKey {
+    userId: string;
+    key: string;
+}
+export interface ListQuery {
+    skip?: number;
+    limit?: number;
+    order?: string;
+}
+export interface StreamCreateMeta {
+    mid?: string;
+    description?: string;
+    p2p?: boolean;
+    tracks?: StreamTrackCreateMeta[];
+}
+export interface StreamTrackCreateMeta {
+    mid?: string;
+    description?: string;
+}
+export interface StreamRemoteInfo {
+    id: StreamId;
+    tracks?: TrackInfo[];
+}
+export interface StreamAndTracksSelector {
+    streamRoomId: StreamRoomId;
+    streamId: StreamId;
+    tracks?: StreamTrackId[];
+}
+export interface Stream {
+    handle: StreamHandle;
+    streamRoomId: StreamRoomId;
+    remote: boolean;
+    createStreamMeta?: StreamCreateMeta;
+    remoteStreamInfo?: StreamRemoteInfo;
+    localMediaStream?: MediaStream;
+}
+export interface StreamList {
+    list: Stream[];
+}
+export type StreamId = number & {
+    __streamId: never;
+};
+export interface DataChannelMeta {
+    name: string;
+}
+export interface StreamTrackMeta {
+    track?: MediaStreamTrack;
+    dataChannel?: DataChannelMeta;
+}
+export interface StreamTrackList {
+    list: TrackInfo[];
+}
+export type StreamTrackId = string & {
+    __streamTrackId: never;
+};
+export interface PublishMeta {
+    bitrate?: number;
+    display?: string;
+}
+export interface TrackInfo extends MediaServerTypes.VideoRoomStreamTrack {
+    type: string;
+    streamRoomId: StreamRoomId;
+    streamId: StreamId;
+    meta?: DataChannelMeta;
+    dataTrackId?: StreamTrackId;
+}
+export type StreamRoomInfo = MediaServerTypes.VideoRoom;
+export type StreamRoomList = MediaServerTypes.RoomListResult;
+export type StreamRoomId = string & {
+    __streamRoomId: never;
+};
+export type TrackType = "audio" | "video" | "data";

package/dist/webStreams/types/ApiTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/webStreams/types/BaseServerTypes.d.ts

@@ -0,0 +1,10 @@
+export interface AppRequest {
+    kind: string;
+    clientId?: string;
+    data?: any;
+}
+export interface RequestOpaque {
+    requestId: number;
+    clientId?: string;
+    request: AppRequest;
+}

package/dist/webStreams/types/BaseServerTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });