@anonotf/connect 0.3.1 → 0.4.1

package/README.md

@@ -141,4 +141,4 @@ recorder.onstop = async () => {
 
 ```js
 client.disconnect();
-```
+```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anonotf/connect",
-  "version": "0.3.1",
-  "description": "Client SDK for AnonOtF — calls, group calls, live streaming, chat, and voice notes.",
+  "version": "0.4.1",
+  "description": "Client SDK for AnonOtF — calls, group calls, live streaming, chat, and voice notes, without touching raw WebRTC or Socket.IO directly.",
   "main": "src/index.js",
   "type": "module",
   "files": ["src"],

package/src/calls.js

@@ -35,6 +35,8 @@ export class Calls {
     this._localStream = null;
     this.roomId = null;                  // set once a call is accepted/joined — null when idle
     this._inCall = false;                // true from accept/connect onward, used to decide whether to mesh-connect to newcomers
+    this._screenTrack = null;            // active screen-capture track, if currently sharing
+    this._hadCameraBeforeShare = false;  // so stopScreenShare() knows whether to restore the camera or just go video-off
 
     this._socket.on('incoming-call', (data) => this._emit('incomingCall', data));
     this._socket.on('call-accepted', (data) => this._onCallAccepted(data));
@@ -99,7 +101,12 @@ export class Calls {
   end() {
     this._socket.emit('end-call', { otherParty: this._anyPeerId() });
     this._cleanupAll();
-    this._emit('callEnded', { from: 'self' });
+    // Deliberately does NOT emit 'callEnded' here — you already know
+    // the call ended, you just called end(). Firing it anyway created
+    // an infinite loop for any consumer whose 'callEnded' handler
+    // reasonably calls end()/cleanup again (the natural thing to do).
+    // 'callEnded' is for when the call ends from elsewhere — the
+    // other party hanging up, a peer connection failing, etc.
   }
 
   /** Notify everyone in the call that you've started/stopped a local recording. */
@@ -140,6 +147,61 @@ export class Calls {
     }
   }
 
+  /**
+   * Starts sharing your screen instead of your camera — swaps the
+   * outgoing video track on every peer connection in the mesh, same
+   * mechanism as camera flip. Remembers whether you had a camera
+   * track running so stopScreenShare() can restore it afterward.
+   * Audio is untouched either way.
+   *
+   * Fires 'screenShareStarted'/'screenShareEnded' — the latter also
+   * fires automatically if the user stops sharing from the browser's
+   * own "Stop sharing" control rather than your UI.
+   */
+  async startScreenShare() {
+    if (this._screenTrack) return; // already sharing
+    const displayStream = await navigator.mediaDevices.getDisplayMedia({ video: true, audio: false });
+    const screenTrack = displayStream.getVideoTracks()[0];
+
+    this._hadCameraBeforeShare = !!this._localStream?.getVideoTracks().length;
+    this._screenTrack = screenTrack;
+
+    await this.replaceVideoTrack(screenTrack);
+    this._emit('screenShareStarted');
+
+    // Browser's native "Stop sharing" UI ends the track directly —
+    // this catches that case so state stays accurate even if the
+    // person never calls stopScreenShare() themselves.
+    screenTrack.onended = () => {
+      if (this._screenTrack === screenTrack) this.stopScreenShare();
+    };
+  }
+
+  /**
+   * Stops screen sharing and restores your camera (if you had one
+   * running before sharing started) across the whole mesh.
+   */
+  async stopScreenShare() {
+    if (!this._screenTrack) return;
+    this._screenTrack.stop();
+    this._screenTrack = null;
+
+    if (this._hadCameraBeforeShare) {
+      const cameraStream = await navigator.mediaDevices.getUserMedia({ video: true });
+      await this.replaceVideoTrack(cameraStream.getVideoTracks()[0]);
+    } else if (this._localStream) {
+      // Wasn't sending video before sharing (audio-only call) — go
+      // back to that, rather than silently turning video on.
+      const track = this._localStream.getVideoTracks()[0];
+      if (track) { this._localStream.removeTrack(track); track.stop(); }
+    }
+    this._emit('screenShareEnded');
+  }
+
+  get isScreenSharing() {
+    return !!this._screenTrack;
+  }
+
   /** Mute/unmute your own mic across the whole mesh — just disables the local track, no renegotiation needed. */
   setMicEnabled(enabled) {
     this._localStream?.getAudioTracks().forEach((t) => { t.enabled = enabled; });
@@ -285,6 +347,8 @@ export class Calls {
   _cleanupAll() {
     this._localStream?.getTracks().forEach((t) => t.stop());
     this._localStream = null;
+    this._screenTrack?.stop();
+    this._screenTrack = null;
     for (const pc of this._peers.values()) pc.close();
     this._peers.clear();
     this.roomId = null;