@needle-tools/engine 3.28.6-beta → 3.28.7-beta.1

package/lib/engine/engine_networking_streams.js

@@ -1,429 +1,429 @@
-import { RoomEvents } from "../engine/engine_networking.js";
-import { getPeerjsInstance } from "../engine/engine_networking_peer.js";
-import { EventDispatcher } from "three";
-import { getParam } from "./engine_utils.js";
-const debug = getParam("debugnetworkingstreams");
-export var NetworkedStreamEvents;
-(function (NetworkedStreamEvents) {
-    NetworkedStreamEvents["Connected"] = "peer-user-connected";
-    NetworkedStreamEvents["StreamReceived"] = "receive-stream";
-    NetworkedStreamEvents["StreamEnded"] = "call-ended";
-    NetworkedStreamEvents["Disconnected"] = "peer-user-disconnected";
-    NetworkedStreamEvents["UserJoined"] = "user-joined";
-})(NetworkedStreamEvents || (NetworkedStreamEvents = {}));
-export class StreamEndedEvent {
-    type = NetworkedStreamEvents.StreamEnded;
-    userId;
-    direction;
-    constructor(userId, direction) {
-        this.userId = userId;
-        this.direction = direction;
-    }
-}
-export class StreamReceivedEvent {
-    type = NetworkedStreamEvents.StreamReceived;
-    stream;
-    target;
-    constructor(stream, target) {
-        this.stream = stream;
-        this.target = target;
-    }
-}
-class PeerUserConnectedModel {
-    /** the peer handle id */
-    guid;
-    peerId;
-    // internal so server doesnt save it to persistent storage
-    dontSave = true;
-    constructor(handle, peerId) {
-        this.guid = handle.id;
-        this.peerId = peerId;
-    }
-}
-export var CallDirection;
-(function (CallDirection) {
-    CallDirection["Incoming"] = "incoming";
-    CallDirection["Outgoing"] = "outgoing";
-})(CallDirection || (CallDirection = {}));
-class CallHandle extends EventDispatcher {
-    userId;
-    direction;
-    call;
-    get stream() { return this._stream; }
-    ;
-    _stream = null;
-    _isDisposed = false;
-    close() {
-        if (this._isDisposed)
-            return;
-        this._isDisposed = true;
-        this.call.close();
-        disposeStream(this._stream);
-    }
-    get isOpen() {
-        return this.call.peerConnection?.connectionState === "connected"; // && this._stream?.active;
-    }
-    get isOpening() {
-        return this.call.peerConnection?.connectionState === "connecting";
-    }
-    get isClosed() {
-        return !this.isOpen;
-    }
-    constructor(userId, call, direction) {
-        super();
-        this.userId = userId;
-        this.call = call;
-        this.direction = direction;
-        this._stream = null;
-        call.on("stream", stream => {
-            if (debug)
-                console.log("Receive video", stream.getAudioTracks(), stream.getVideoTracks());
-            this._stream = stream;
-            if (direction === CallDirection.Incoming) {
-                const args = new StreamReceivedEvent(stream, this);
-                this.dispatchEvent(args);
-            }
-        });
-        call.on("close", () => {
-            this.dispatchEvent(new StreamEndedEvent(userId, direction));
-        });
-    }
-}
-export class PeerHandle extends EventDispatcher {
-    static instances = new Map();
-    static getOrCreate(context, guid) {
-        // if (id === undefined) {
-        //     // randomId
-        //     id = Math.random().toFixed(5);
-        // }
-        if (PeerHandle.instances.has(guid))
-            return PeerHandle.instances.get(guid);
-        const peer = new PeerHandle(context, guid);
-        PeerHandle.instances.set(guid, peer);
-        return peer;
-    }
-    getMyPeerId() {
-        if (this.context.connection.connectionId)
-            return this.getPeerIdFromUserId(this.context.connection.connectionId);
-        return undefined;
-    }
-    getPeerIdFromUserId(userConnectionId) {
-        // we build the peer id ourselves so we dont need to wait for peer to report it
-        return this.id + "-" + userConnectionId;
-    }
-    getUserIdFromPeerId(peerId) {
-        return peerId.substring(this.id.length + 1);
-    }
-    makeCall(peerId, stream) {
-        const opts = { metadata: { userId: this.context.connection.connectionId } };
-        const call = this._peer?.call(peerId, stream, opts);
-        if (call)
-            return this.registerCall(call, CallDirection.Outgoing);
-        return undefined;
-    }
-    get peer() { return this._peer; }
-    id;
-    context;
-    _peer;
-    _incomingCalls = [];
-    _outgoingCalls = [];
-    constructor(context, id) {
-        super();
-        this.context = context;
-        this.id = id;
-        this.setupPeer();
-        navigator["getUserMedia"] = (navigator["getUserMedia"] || navigator["webkitGetUserMedia"] ||
-            navigator["mozGetUserMedia"] || navigator["msGetUserMedia"]);
-    }
-    _enabled = false;
-    _enabledPeer = false;
-    onConnectRoomFn = this.onConnectRoom.bind(this);
-    // private onUserJoinedOrLeftRoomFn: Function = this.onUserJoinedOrLeftRoom.bind(this);
-    onPeerConnectFn = this.onPeerConnect.bind(this);
-    onPeerReceiveCallFn = this.onPeerReceivingCall.bind(this);
-    // private _connectionPeerIdMap : Map<string, string> = new Map();
-    enable() {
-        if (this._enabled)
-            return;
-        this._enabled = true;
-        this.context.connection.beginListen(RoomEvents.JoinedRoom, this.onConnectRoomFn);
-        // this.context.connection.beginListen(RoomEvents.UserJoinedRoom, this.onUserJoinedOrLeftRoomFn);
-        // this.context.connection.beginListen(RoomEvents.UserLeftRoom, this.onUserJoinedOrLeftRoomFn);
-        this.subscribePeerEvents();
-    }
-    disable() {
-        if (!this._enabled)
-            return;
-        this._enabled = false;
-        this.context.connection.stopListen(RoomEvents.JoinedRoom, this.onConnectRoomFn);
-        // this.context.connection.stopListen(RoomEvents.UserJoinedRoom, this.onUserJoinedOrLeftRoomFn);
-        // this.context.connection.stopListen(RoomEvents.UserLeftRoom, this.onUserJoinedOrLeftRoomFn);
-        this.unsubscribePeerEvents();
-    }
-    onConnectRoom() {
-        this.setupPeer();
-    }
-    ;
-    // private onUserJoinedOrLeftRoom(_: UserJoinedOrLeftRoomModel): void {
-    // };
-    setupPeer() {
-        if (!this.context.connection.connectionId)
-            return;
-        if (this._enabledPeer)
-            return;
-        this._enabledPeer = true;
-        if (!this._peer) {
-            const peerId = this.getMyPeerId();
-            if (peerId)
-                this._peer = getPeerjsInstance(peerId);
-            else
-                console.error("Failed to setup peerjs because we dont have a connection id", this.context.connection.connectionId);
-        }
-        if (this._enabled)
-            this.subscribePeerEvents();
-    }
-    subscribePeerEvents() {
-        if (!this._peer)
-            return;
-        this._peer.on("open", this.onPeerConnectFn);
-        this._peer.on("call", this.onPeerReceiveCallFn);
-        // this.context.connection.beginListen(PeerEvent.Connected, this.onRemotePeerConnect.bind(this));
-        // TODO: make connection to all current active calls even if the user is not anymore in the needle room
-    }
-    unsubscribePeerEvents() {
-        if (!this._peer)
-            return;
-        this._peer.off("open", this.onPeerConnectFn);
-        this._peer.off("call", this.onPeerReceiveCallFn);
-        // this.context.connection.stopListen(PeerEvent.Connected, this.onRemotePeerConnect.bind(this));
-    }
-    onPeerConnect(id) {
-        if (debug)
-            console.log("Peer connected as", id);
-        this.context.connection.send(NetworkedStreamEvents.Connected, new PeerUserConnectedModel(this, id));
-    }
-    onPeerReceivingCall(call) {
-        call.answer();
-        this.registerCall(call, CallDirection.Incoming);
-    }
-    registerCall(call, direction) {
-        const meta = call.metadata;
-        if (!meta || !meta.userId) {
-            console.error("Missing call metadata", call);
-        }
-        const userId = meta.userId;
-        if (direction === CallDirection.Incoming && debug)
-            console.log("Receive call from", call.metadata);
-        else if (debug)
-            console.log("Make call to", call.metadata);
-        const arr = direction === CallDirection.Incoming ? this._incomingCalls : this._outgoingCalls;
-        const handle = new CallHandle(userId, call, direction);
-        arr.push(handle);
-        call.on("error", err => {
-            console.error("Call error", err);
-        });
-        call.on("close", () => {
-            if (debug)
-                console.log("Call ended", call.metadata);
-            call.close();
-            const index = arr.indexOf(handle);
-            if (index !== -1)
-                arr.splice(index, 1);
-        });
-        handle.addEventListener(NetworkedStreamEvents.StreamEnded, e => {
-            this.dispatchEvent(e);
-        });
-        if (direction === CallDirection.Incoming) {
-            handle.addEventListener(NetworkedStreamEvents.StreamReceived, e => {
-                this.dispatchEvent(e);
-            });
-            call.on("stream", () => {
-                // workaround for https://github.com/peers/peerjs/issues/636
-                let intervalCounter = 0;
-                const closeInterval = setInterval(() => {
-                    const isFirstInterval = intervalCounter === 0;
-                    if (!handle.isOpen && isFirstInterval) {
-                        intervalCounter += 1;
-                        clearInterval(closeInterval);
-                        handle.close();
-                    }
-                }, 2000);
-            });
-        }
-        return handle;
-    }
-}
-// type UserVideoCall = {
-//     call: Peer.MediaConnection;
-//     stream: MediaStream;
-//     userId: string;
-// }
-// type IncomingStreamArgs = {
-//     stream: MediaStream;
-//     userId: string;
-// }
-export class NetworkedStreams extends EventDispatcher {
-    static create(comp) {
-        const peer = PeerHandle.getOrCreate(comp.context, comp.context.connection.connectionId);
-        return new NetworkedStreams(comp.context, peer);
-    }
-    context;
-    peer;
-    // private _receiveVideoStreamListeners: Array<(info: IncomingStreamArgs) => void> = [];
-    _sendingStreams = new Map();
-    debug = false;
-    constructor(context, peer) {
-        super();
-        this.context = context;
-        this.peer = peer;
-        if (debug)
-            this.debug = true;
-    }
-    startSendingStream(stream) {
-        if (!this._sendingStreams.has(stream)) {
-            this._sendingStreams.set(stream, []);
-            this.updateSendingCalls();
-        }
-        else {
-            console.warn("Received start sending stream with stream that is already being sent");
-        }
-    }
-    stopSendingStream(_steam) {
-        if (_steam) {
-            const calls = this._sendingStreams.get(_steam);
-            if (calls) {
-                if (this.debug)
-                    console.log("Closing calls", calls);
-                for (const call of calls) {
-                    call.close();
-                }
-            }
-            this._sendingStreams.delete(_steam);
-            if (calls && this.debug)
-                console.log("Currently sending", this._sendingStreams);
-        }
-    }
-    // private onConnectRoomFn: Function = this.onConnectRoom.bind(this);
-    // private onUserConnectedFn: Function = this.onUserConnected.bind(this);
-    // private onUserLeftFn: Function = this.onUserLeft.bind(this);
-    enable() {
-        this.peer.enable();
-        this.peer.addEventListener(NetworkedStreamEvents.StreamReceived, this.onReceiveStream);
-        //@ts-ignore
-        this.peer.addEventListener(NetworkedStreamEvents.StreamEnded, this.onCallEnded);
-        // this.peer.addEventListener(PeerEvent.UserJoined, this.onUserJoinedPeer);
-        this.context.connection.beginListen(NetworkedStreamEvents.Connected, this.onUserConnected);
-        this.context.connection.beginListen(RoomEvents.JoinedRoom, this.onJoinedRoom);
-        this.context.connection.beginListen(RoomEvents.UserJoinedRoom, this.onJoinedRoom);
-        this.context.connection.beginListen(RoomEvents.UserLeftRoom, this.onUserLeft);
-    }
-    disable() {
-        this.peer.disable();
-        this.peer.removeEventListener(NetworkedStreamEvents.StreamReceived, this.onReceiveStream);
-        //@ts-ignore
-        this.peer.removeEventListener(NetworkedStreamEvents.StreamEnded, this.onCallEnded);
-        // this.peer.removeEventListener(PeerEvent.UserJoined, this.onUserJoinedPeer);
-        this.context.connection.stopListen(NetworkedStreamEvents.Connected, this.onUserConnected);
-        this.context.connection.stopListen(RoomEvents.JoinedRoom, this.onJoinedRoom);
-        this.context.connection.stopListen(RoomEvents.UserJoinedRoom, this.onJoinedRoom);
-        this.context.connection.stopListen(RoomEvents.UserLeftRoom, this.onUserLeft);
-    }
-    // private onUserJoinedPeer = (evt) => {
-    //     if (!this.context.connection.isConnected && evt.userId) {
-    //         this.startCallWithUserIfNotAlready(evt.userId);
-    //     }
-    // }
-    // When either we ourselves OR someone else is joining the room we want to make sure to re-establish all calls
-    // and if the user that joined is not yet receiving our video stream we want to start a stream with them
-    // https://github.com/needle-tools/needle-tiny/issues/697#issuecomment-1510425539
-    onJoinedRoom = (evt) => {
-        if (this.debug)
-            console.log(`${evt.userId} joined room and I'm currently sending ${this._sendingStreams.size} streams`);
-        if (this._sendingStreams.size > 0)
-            this.updateSendingCalls();
-    };
-    onReceiveStream = (evt) => {
-        if (this.debug)
-            console.log("RECEIVE STREAM", evt);
-        this.dispatchEvent({ type: NetworkedStreamEvents.StreamReceived, target: this, stream: evt.stream, userId: evt.userId });
-    };
-    onCallEnded = (evt) => {
-        this.dispatchEvent(evt);
-    };
-    onUserConnected = (user) => {
-        // console.log(this.peer.id, user.guid)
-        if (this.peer.id === user.guid) {
-            if (this.debug)
-                console.log("USER CONNECTED", user.guid, user);
-            const stream = this._sendingStreams.keys().next().value;
-            this.peer.makeCall(user.peerId, stream);
-        }
-    };
-    onUserLeft = (_) => {
-        this.stopCallsToUsersThatAreNotInTheRoomAnymore();
-    };
-    updateSendingCalls() {
-        let startedNewCall = false;
-        const localUserId = this.context.connection.connectionId;
-        for (const stream of this._sendingStreams.keys()) {
-            const calls = this._sendingStreams.get(stream) || [];
-            for (const userId of this.context.connection.usersInRoom()) {
-                if (userId === localUserId)
-                    continue;
-                const existing = calls.find(c => c.userId === userId);
-                if (!existing || existing.stream?.active === false) {
-                    if (this.debug)
-                        console.log("Starting call to", userId, localUserId);
-                    const handle = this.peer.makeCall(this.peer.getPeerIdFromUserId(userId), stream);
-                    if (handle) {
-                        startedNewCall = true;
-                        calls.push(handle);
-                    }
-                }
-            }
-            this._sendingStreams.set(stream, calls);
-        }
-        this.stopCallsToUsersThatAreNotInTheRoomAnymore();
-        if (startedNewCall && this.debug) {
-            console.log("Currently sending", this._sendingStreams);
-        }
-    }
-    // private startCallWithUserIfNotAlready(userId: string) {
-    //     for (const stream of this._sendingVideoStreams.keys()) {
-    //         const calls = this._sendingVideoStreams.get(stream) || [];
-    //         const existing = calls.find(c => c.userId === userId);
-    //         if (!existing || existing.stream?.active === false) {
-    //             if (this.debug) console.log("Starting call to", userId)
-    //             const handle = this.peer.makeCall(this.peer.getPeerIdFromUserId(userId), stream);
-    //             if (handle) {
-    //                 calls.push(handle);
-    //                 return true;
-    //             }
-    //         }
-    //     }
-    //     return false;
-    // }
-    stopCallsToUsersThatAreNotInTheRoomAnymore() {
-        for (const stream of this._sendingStreams.keys()) {
-            const calls = this._sendingStreams.get(stream);
-            if (!calls)
-                continue;
-            for (let i = calls.length - 1; i >= 0; i--) {
-                const call = calls[i];
-                if (!this.context.connection.userIsInRoom(call.userId)) {
-                    call.close();
-                    calls.splice(i, 1);
-                }
-            }
-        }
-    }
-}
-export function disposeStream(str) {
-    if (!str)
-        return;
-    if (str instanceof MediaStream) {
-        for (const cap of str.getTracks())
-            cap.stop();
-    }
-}
+import { RoomEvents } from "../engine/engine_networking.js";
+import { getPeerjsInstance } from "../engine/engine_networking_peer.js";
+import { EventDispatcher } from "three";
+import { getParam } from "./engine_utils.js";
+const debug = getParam("debugnetworkingstreams");
+export var NetworkedStreamEvents;
+(function (NetworkedStreamEvents) {
+    NetworkedStreamEvents["Connected"] = "peer-user-connected";
+    NetworkedStreamEvents["StreamReceived"] = "receive-stream";
+    NetworkedStreamEvents["StreamEnded"] = "call-ended";
+    NetworkedStreamEvents["Disconnected"] = "peer-user-disconnected";
+    NetworkedStreamEvents["UserJoined"] = "user-joined";
+})(NetworkedStreamEvents || (NetworkedStreamEvents = {}));
+export class StreamEndedEvent {
+    type = NetworkedStreamEvents.StreamEnded;
+    userId;
+    direction;
+    constructor(userId, direction) {
+        this.userId = userId;
+        this.direction = direction;
+    }
+}
+export class StreamReceivedEvent {
+    type = NetworkedStreamEvents.StreamReceived;
+    stream;
+    target;
+    constructor(stream, target) {
+        this.stream = stream;
+        this.target = target;
+    }
+}
+class PeerUserConnectedModel {
+    /** the peer handle id */
+    guid;
+    peerId;
+    // internal so server doesnt save it to persistent storage
+    dontSave = true;
+    constructor(handle, peerId) {
+        this.guid = handle.id;
+        this.peerId = peerId;
+    }
+}
+export var CallDirection;
+(function (CallDirection) {
+    CallDirection["Incoming"] = "incoming";
+    CallDirection["Outgoing"] = "outgoing";
+})(CallDirection || (CallDirection = {}));
+class CallHandle extends EventDispatcher {
+    userId;
+    direction;
+    call;
+    get stream() { return this._stream; }
+    ;
+    _stream = null;
+    _isDisposed = false;
+    close() {
+        if (this._isDisposed)
+            return;
+        this._isDisposed = true;
+        this.call.close();
+        disposeStream(this._stream);
+    }
+    get isOpen() {
+        return this.call.peerConnection?.connectionState === "connected"; // && this._stream?.active;
+    }
+    get isOpening() {
+        return this.call.peerConnection?.connectionState === "connecting";
+    }
+    get isClosed() {
+        return !this.isOpen;
+    }
+    constructor(userId, call, direction) {
+        super();
+        this.userId = userId;
+        this.call = call;
+        this.direction = direction;
+        this._stream = null;
+        call.on("stream", stream => {
+            if (debug)
+                console.log("Receive video", stream.getAudioTracks(), stream.getVideoTracks());
+            this._stream = stream;
+            if (direction === CallDirection.Incoming) {
+                const args = new StreamReceivedEvent(stream, this);
+                this.dispatchEvent(args);
+            }
+        });
+        call.on("close", () => {
+            this.dispatchEvent(new StreamEndedEvent(userId, direction));
+        });
+    }
+}
+export class PeerHandle extends EventDispatcher {
+    static instances = new Map();
+    static getOrCreate(context, guid) {
+        // if (id === undefined) {
+        //     // randomId
+        //     id = Math.random().toFixed(5);
+        // }
+        if (PeerHandle.instances.has(guid))
+            return PeerHandle.instances.get(guid);
+        const peer = new PeerHandle(context, guid);
+        PeerHandle.instances.set(guid, peer);
+        return peer;
+    }
+    getMyPeerId() {
+        if (this.context.connection.connectionId)
+            return this.getPeerIdFromUserId(this.context.connection.connectionId);
+        return undefined;
+    }
+    getPeerIdFromUserId(userConnectionId) {
+        // we build the peer id ourselves so we dont need to wait for peer to report it
+        return this.id + "-" + userConnectionId;
+    }
+    getUserIdFromPeerId(peerId) {
+        return peerId.substring(this.id.length + 1);
+    }
+    makeCall(peerId, stream) {
+        const opts = { metadata: { userId: this.context.connection.connectionId } };
+        const call = this._peer?.call(peerId, stream, opts);
+        if (call)
+            return this.registerCall(call, CallDirection.Outgoing);
+        return undefined;
+    }
+    get peer() { return this._peer; }
+    id;
+    context;
+    _peer;
+    _incomingCalls = [];
+    _outgoingCalls = [];
+    constructor(context, id) {
+        super();
+        this.context = context;
+        this.id = id;
+        this.setupPeer();
+        navigator["getUserMedia"] = (navigator["getUserMedia"] || navigator["webkitGetUserMedia"] ||
+            navigator["mozGetUserMedia"] || navigator["msGetUserMedia"]);
+    }
+    _enabled = false;
+    _enabledPeer = false;
+    onConnectRoomFn = this.onConnectRoom.bind(this);
+    // private onUserJoinedOrLeftRoomFn: Function = this.onUserJoinedOrLeftRoom.bind(this);
+    onPeerConnectFn = this.onPeerConnect.bind(this);
+    onPeerReceiveCallFn = this.onPeerReceivingCall.bind(this);
+    // private _connectionPeerIdMap : Map<string, string> = new Map();
+    enable() {
+        if (this._enabled)
+            return;
+        this._enabled = true;
+        this.context.connection.beginListen(RoomEvents.JoinedRoom, this.onConnectRoomFn);
+        // this.context.connection.beginListen(RoomEvents.UserJoinedRoom, this.onUserJoinedOrLeftRoomFn);
+        // this.context.connection.beginListen(RoomEvents.UserLeftRoom, this.onUserJoinedOrLeftRoomFn);
+        this.subscribePeerEvents();
+    }
+    disable() {
+        if (!this._enabled)
+            return;
+        this._enabled = false;
+        this.context.connection.stopListen(RoomEvents.JoinedRoom, this.onConnectRoomFn);
+        // this.context.connection.stopListen(RoomEvents.UserJoinedRoom, this.onUserJoinedOrLeftRoomFn);
+        // this.context.connection.stopListen(RoomEvents.UserLeftRoom, this.onUserJoinedOrLeftRoomFn);
+        this.unsubscribePeerEvents();
+    }
+    onConnectRoom() {
+        this.setupPeer();
+    }
+    ;
+    // private onUserJoinedOrLeftRoom(_: UserJoinedOrLeftRoomModel): void {
+    // };
+    setupPeer() {
+        if (!this.context.connection.connectionId)
+            return;
+        if (this._enabledPeer)
+            return;
+        this._enabledPeer = true;
+        if (!this._peer) {
+            const peerId = this.getMyPeerId();
+            if (peerId)
+                this._peer = getPeerjsInstance(peerId);
+            else
+                console.error("Failed to setup peerjs because we dont have a connection id", this.context.connection.connectionId);
+        }
+        if (this._enabled)
+            this.subscribePeerEvents();
+    }
+    subscribePeerEvents() {
+        if (!this._peer)
+            return;
+        this._peer.on("open", this.onPeerConnectFn);
+        this._peer.on("call", this.onPeerReceiveCallFn);
+        // this.context.connection.beginListen(PeerEvent.Connected, this.onRemotePeerConnect.bind(this));
+        // TODO: make connection to all current active calls even if the user is not anymore in the needle room
+    }
+    unsubscribePeerEvents() {
+        if (!this._peer)
+            return;
+        this._peer.off("open", this.onPeerConnectFn);
+        this._peer.off("call", this.onPeerReceiveCallFn);
+        // this.context.connection.stopListen(PeerEvent.Connected, this.onRemotePeerConnect.bind(this));
+    }
+    onPeerConnect(id) {
+        if (debug)
+            console.log("Peer connected as", id);
+        this.context.connection.send(NetworkedStreamEvents.Connected, new PeerUserConnectedModel(this, id));
+    }
+    onPeerReceivingCall(call) {
+        call.answer();
+        this.registerCall(call, CallDirection.Incoming);
+    }
+    registerCall(call, direction) {
+        const meta = call.metadata;
+        if (!meta || !meta.userId) {
+            console.error("Missing call metadata", call);
+        }
+        const userId = meta.userId;
+        if (direction === CallDirection.Incoming && debug)
+            console.log("Receive call from", call.metadata);
+        else if (debug)
+            console.log("Make call to", call.metadata);
+        const arr = direction === CallDirection.Incoming ? this._incomingCalls : this._outgoingCalls;
+        const handle = new CallHandle(userId, call, direction);
+        arr.push(handle);
+        call.on("error", err => {
+            console.error("Call error", err);
+        });
+        call.on("close", () => {
+            if (debug)
+                console.log("Call ended", call.metadata);
+            call.close();
+            const index = arr.indexOf(handle);
+            if (index !== -1)
+                arr.splice(index, 1);
+        });
+        handle.addEventListener(NetworkedStreamEvents.StreamEnded, e => {
+            this.dispatchEvent(e);
+        });
+        if (direction === CallDirection.Incoming) {
+            handle.addEventListener(NetworkedStreamEvents.StreamReceived, e => {
+                this.dispatchEvent(e);
+            });
+            call.on("stream", () => {
+                // workaround for https://github.com/peers/peerjs/issues/636
+                let intervalCounter = 0;
+                const closeInterval = setInterval(() => {
+                    const isFirstInterval = intervalCounter === 0;
+                    if (!handle.isOpen && isFirstInterval) {
+                        intervalCounter += 1;
+                        clearInterval(closeInterval);
+                        handle.close();
+                    }
+                }, 2000);
+            });
+        }
+        return handle;
+    }
+}
+// type UserVideoCall = {
+//     call: Peer.MediaConnection;
+//     stream: MediaStream;
+//     userId: string;
+// }
+// type IncomingStreamArgs = {
+//     stream: MediaStream;
+//     userId: string;
+// }
+export class NetworkedStreams extends EventDispatcher {
+    static create(comp) {
+        const peer = PeerHandle.getOrCreate(comp.context, comp.context.connection.connectionId);
+        return new NetworkedStreams(comp.context, peer);
+    }
+    context;
+    peer;
+    // private _receiveVideoStreamListeners: Array<(info: IncomingStreamArgs) => void> = [];
+    _sendingStreams = new Map();
+    debug = false;
+    constructor(context, peer) {
+        super();
+        this.context = context;
+        this.peer = peer;
+        if (debug)
+            this.debug = true;
+    }
+    startSendingStream(stream) {
+        if (!this._sendingStreams.has(stream)) {
+            this._sendingStreams.set(stream, []);
+            this.updateSendingCalls();
+        }
+        else {
+            console.warn("Received start sending stream with stream that is already being sent");
+        }
+    }
+    stopSendingStream(_steam) {
+        if (_steam) {
+            const calls = this._sendingStreams.get(_steam);
+            if (calls) {
+                if (this.debug)
+                    console.log("Closing calls", calls);
+                for (const call of calls) {
+                    call.close();
+                }
+            }
+            this._sendingStreams.delete(_steam);
+            if (calls && this.debug)
+                console.log("Currently sending", this._sendingStreams);
+        }
+    }
+    // private onConnectRoomFn: Function = this.onConnectRoom.bind(this);
+    // private onUserConnectedFn: Function = this.onUserConnected.bind(this);
+    // private onUserLeftFn: Function = this.onUserLeft.bind(this);
+    enable() {
+        this.peer.enable();
+        this.peer.addEventListener(NetworkedStreamEvents.StreamReceived, this.onReceiveStream);
+        //@ts-ignore
+        this.peer.addEventListener(NetworkedStreamEvents.StreamEnded, this.onCallEnded);
+        // this.peer.addEventListener(PeerEvent.UserJoined, this.onUserJoinedPeer);
+        this.context.connection.beginListen(NetworkedStreamEvents.Connected, this.onUserConnected);
+        this.context.connection.beginListen(RoomEvents.JoinedRoom, this.onJoinedRoom);
+        this.context.connection.beginListen(RoomEvents.UserJoinedRoom, this.onJoinedRoom);
+        this.context.connection.beginListen(RoomEvents.UserLeftRoom, this.onUserLeft);
+    }
+    disable() {
+        this.peer.disable();
+        this.peer.removeEventListener(NetworkedStreamEvents.StreamReceived, this.onReceiveStream);
+        //@ts-ignore
+        this.peer.removeEventListener(NetworkedStreamEvents.StreamEnded, this.onCallEnded);
+        // this.peer.removeEventListener(PeerEvent.UserJoined, this.onUserJoinedPeer);
+        this.context.connection.stopListen(NetworkedStreamEvents.Connected, this.onUserConnected);
+        this.context.connection.stopListen(RoomEvents.JoinedRoom, this.onJoinedRoom);
+        this.context.connection.stopListen(RoomEvents.UserJoinedRoom, this.onJoinedRoom);
+        this.context.connection.stopListen(RoomEvents.UserLeftRoom, this.onUserLeft);
+    }
+    // private onUserJoinedPeer = (evt) => {
+    //     if (!this.context.connection.isConnected && evt.userId) {
+    //         this.startCallWithUserIfNotAlready(evt.userId);
+    //     }
+    // }
+    // When either we ourselves OR someone else is joining the room we want to make sure to re-establish all calls
+    // and if the user that joined is not yet receiving our video stream we want to start a stream with them
+    // https://github.com/needle-tools/needle-tiny/issues/697#issuecomment-1510425539
+    onJoinedRoom = (evt) => {
+        if (this.debug)
+            console.log(`${evt.userId} joined room and I'm currently sending ${this._sendingStreams.size} streams`);
+        if (this._sendingStreams.size > 0)
+            this.updateSendingCalls();
+    };
+    onReceiveStream = (evt) => {
+        if (this.debug)
+            console.log("RECEIVE STREAM", evt);
+        this.dispatchEvent({ type: NetworkedStreamEvents.StreamReceived, target: this, stream: evt.stream, userId: evt.userId });
+    };
+    onCallEnded = (evt) => {
+        this.dispatchEvent(evt);
+    };
+    onUserConnected = (user) => {
+        // console.log(this.peer.id, user.guid)
+        if (this.peer.id === user.guid) {
+            if (this.debug)
+                console.log("USER CONNECTED", user.guid, user);
+            const stream = this._sendingStreams.keys().next().value;
+            this.peer.makeCall(user.peerId, stream);
+        }
+    };
+    onUserLeft = (_) => {
+        this.stopCallsToUsersThatAreNotInTheRoomAnymore();
+    };
+    updateSendingCalls() {
+        let startedNewCall = false;
+        const localUserId = this.context.connection.connectionId;
+        for (const stream of this._sendingStreams.keys()) {
+            const calls = this._sendingStreams.get(stream) || [];
+            for (const userId of this.context.connection.usersInRoom()) {
+                if (userId === localUserId)
+                    continue;
+                const existing = calls.find(c => c.userId === userId);
+                if (!existing || existing.stream?.active === false) {
+                    if (this.debug)
+                        console.log("Starting call to", userId, localUserId);
+                    const handle = this.peer.makeCall(this.peer.getPeerIdFromUserId(userId), stream);
+                    if (handle) {
+                        startedNewCall = true;
+                        calls.push(handle);
+                    }
+                }
+            }
+            this._sendingStreams.set(stream, calls);
+        }
+        this.stopCallsToUsersThatAreNotInTheRoomAnymore();
+        if (startedNewCall && this.debug) {
+            console.log("Currently sending", this._sendingStreams);
+        }
+    }
+    // private startCallWithUserIfNotAlready(userId: string) {
+    //     for (const stream of this._sendingVideoStreams.keys()) {
+    //         const calls = this._sendingVideoStreams.get(stream) || [];
+    //         const existing = calls.find(c => c.userId === userId);
+    //         if (!existing || existing.stream?.active === false) {
+    //             if (this.debug) console.log("Starting call to", userId)
+    //             const handle = this.peer.makeCall(this.peer.getPeerIdFromUserId(userId), stream);
+    //             if (handle) {
+    //                 calls.push(handle);
+    //                 return true;
+    //             }
+    //         }
+    //     }
+    //     return false;
+    // }
+    stopCallsToUsersThatAreNotInTheRoomAnymore() {
+        for (const stream of this._sendingStreams.keys()) {
+            const calls = this._sendingStreams.get(stream);
+            if (!calls)
+                continue;
+            for (let i = calls.length - 1; i >= 0; i--) {
+                const call = calls[i];
+                if (!this.context.connection.userIsInRoom(call.userId)) {
+                    call.close();
+                    calls.splice(i, 1);
+                }
+            }
+        }
+    }
+}
+export function disposeStream(str) {
+    if (!str)
+        return;
+    if (str instanceof MediaStream) {
+        for (const cap of str.getTracks())
+            cap.stop();
+    }
+}
 //# sourceMappingURL=engine_networking_streams.js.map