topazcube 0.1.21 → 0.1.23

package/README.md

@@ -23,7 +23,9 @@ const server = new TopazCubeServer({
 
 ### WebRTC Support (Optional)
 
-WebRTC functionality is optional and requires platform-specific binary packages. If you want to use WebRTC features:
+WebRTC functionality is optional and requires platform-specific binary packages. **Note: WebRTC is only available when using the CommonJS build due to native module limitations.**
+
+If you want to use WebRTC features:
 
 ```bash
 # Install the appropriate platform package
@@ -32,15 +34,30 @@ npm install @roamhq/wrtc-linux-x64   # for Linux x64
 npm install @roamhq/wrtc-win32-x64   # for Windows x64
 ```
 
-Then enable WebRTC in your server:
+Then use the CommonJS build and enable WebRTC:
+
+```javascript
+// Use require() and .cjs build for WebRTC support
+const TopazCubeServer = require('topazcube/server').default;
 
-```typescript
 const server = new TopazCubeServer({
   port: 8799,
   allowWebRTC: true // Enable WebRTC functionality
 })
 ```
 
+For ESM imports without WebRTC:
+
+```typescript
+// ESM import works fine without WebRTC
+import TopazCubeServer from 'topazcube/server'
+
+const server = new TopazCubeServer({
+  port: 8799,
+  allowWebRTC: false // WebRTC not available in ESM mode
+})
+```
+
 ### Client Setup
 
 ```typescript

package/dist/client.cjs

@@ -174,7 +174,7 @@ async function decompress(buffer) {
 // src/client.ts
 var import_gl_matrix = require("gl-matrix");
 var TopazCubeClient = class {
-  debug = false;
+  DEBUG = false;
   CYCLE = 200;
   // update/patch rate in ms
   url = "";
@@ -205,6 +205,9 @@ var TopazCubeClient = class {
   ID = 0;
   socket = null;
   _peerConnection = null;
+  _candidates = [];
+  _remoteCandidates = [];
+  _offerSent = false;
   _dataChannel = null;
   // our data channel
   _serverDataChannel = null;
@@ -228,15 +231,30 @@ var TopazCubeClient = class {
     // auto reconnect on disconnect
     allowSync = true,
     // allow sync on connect
-    allowWebRTC = false
+    allowWebRTC = false,
+    DEBUG = false
   }) {
     this.url = url;
     this.autoReconnect = autoReconnect;
     this.allowSync = allowSync;
     this.allowWebRTC = allowWebRTC;
     this.socket = null;
+    this.DEBUG = DEBUG;
     this._startLoop();
-    console.log("Client initialized");
+    this.log("Client initialized");
+  }
+  log(...args) {
+    if (this.DEBUG) {
+      console.log(...args);
+    }
+  }
+  warn(...args) {
+    if (this.DEBUG) {
+      console.warn(...args);
+    }
+  }
+  error(...args) {
+    console.error(...args);
   }
   /*= UPDATE ===================================================================*/
   _startLoop() {
@@ -307,20 +325,32 @@ var TopazCubeClient = class {
           let t2 = e._lpostime2;
           const interval = t2 - t1;
           const elapsed = now - t1;
-          const alpha = Math.max(0, elapsed / interval);
-          import_gl_matrix.vec3.lerp(this._dpos, e._lpos1, e._lpos2, alpha);
-          import_gl_matrix.vec3.lerp(e.position, e.position, this._dpos, 0.07);
-          e._changed_position = now;
+          e.pelapsed = elapsed;
+          if (elapsed > 1e3) {
+            import_gl_matrix.vec3.copy(e.position, e._lpos2);
+            e._changed_position = now;
+          } else {
+            const alpha = Math.max(0, elapsed / interval);
+            import_gl_matrix.vec3.lerp(this._dpos, e._lpos1, e._lpos2, alpha);
+            import_gl_matrix.vec3.lerp(e.position, e.position, this._dpos, 0.07);
+            e._changed_position = now;
+          }
         }
         if (e._lrottime1 && e._lrottime2) {
           let t1 = e._lrottime1;
           let t2 = e._lrottime2;
           const interval = t2 - t1;
           const elapsed = now - t1;
-          const alpha = Math.max(0, elapsed / interval);
-          import_gl_matrix.quat.slerp(this._drot, e._lrot1, e._lrot2, alpha);
-          import_gl_matrix.quat.slerp(e.rotation, e.rotation, this._drot, 0.07);
-          e._changed_rotation = now;
+          e.relapsed = elapsed;
+          if (elapsed > 1e3) {
+            import_gl_matrix.quat.copy(e.rotation, e._lrot2);
+            e._changed_rotation = now;
+          } else {
+            const alpha = Math.max(0, elapsed / interval);
+            import_gl_matrix.quat.slerp(this._drot, e._lrot1, e._lrot2, alpha);
+            import_gl_matrix.quat.slerp(e.rotation, e.rotation, this._drot, 0.07);
+            e._changed_rotation = now;
+          }
         }
       }
     }
@@ -341,7 +371,7 @@ var TopazCubeClient = class {
     }
     this.isConnecting = true;
     this._clear();
-    console.log("connecting...");
+    this.log("connecting...");
     this.socket = new WebSocket(this.url);
     this.socket.onmessage = async (event) => {
       let buffer = await event.data.arrayBuffer();
@@ -448,7 +478,7 @@ var TopazCubeClient = class {
         this.socket.send(enc);
       }
     } catch (e) {
-      console.error("send failed", e);
+      this.error("send failed", e);
     }
   }
   get document() {
@@ -486,7 +516,7 @@ var TopazCubeClient = class {
           try {
             (0, import_fast_json_patch.applyOperation)(this.documents[name], dop);
           } catch (e) {
-            console.error("applyOperation failed for", name, "with op", dop, e);
+            this.error("applyOperation failed for", name, "with op", dop, e);
           }
         }
         this.isPatched = false;
@@ -517,10 +547,10 @@ var TopazCubeClient = class {
             let nmessage = decode(cdecu);
             this._onMessage(nmessage);
           } catch (error) {
-            console.error("Error decoding chunks:", error);
+            this.error("Error decoding chunks:", error);
           }
         } else {
-          console.warn("missing chunks", cfound, "of", message.seq + 1);
+          this.warn("missing chunks", cfound, "of", message.seq + 1);
         }
       }
     } else if (message.c == "fpatch") {
@@ -533,11 +563,11 @@ var TopazCubeClient = class {
         if (this._lastUpdateId[name] < message.u) {
           let lp = message.u - this._lastUpdateId[name] - 1;
           if (lp > 0) {
-            console.warn("Lost " + lp + " updates");
+            this.warn("Lost " + lp + " updates");
           }
           this._lastUpdateId[name] = message.u;
         } else if (this._lastUpdateId[name] > message.u) {
-          console.warn(`Received outdated update ID for document ${name}: ${message.u} < ${this._lastUpdateId[name]}`);
+          this.warn(`Received outdated update ID for document ${name}: ${message.u} < ${this._lastUpdateId[name]}`);
           doPatch = false;
         }
       }
@@ -553,9 +583,11 @@ var TopazCubeClient = class {
       this.send({ c: "peng", ct: Date.now(), st: stime });
       this.stats.stdiff = stime + ping / 2 - time;
       this.stats.ping = ping;
-      console.log("ping", ping, "ms", "stdiff", this.stats.stdiff, "ms");
+      this.log("ping", ping, "ms", "stdiff", this.stats.stdiff, "ms");
     } else if (message.c == "rtc-offer") {
+      this.log("RTC: offer received:", message);
     } else if (message.c == "rtc-answer") {
+      this.log("RTC: answer received:", message);
       try {
         const sessionDesc = new RTCSessionDescription({
           type: message.type,
@@ -564,30 +596,30 @@ var TopazCubeClient = class {
         if (this._peerConnection) {
           await this._peerConnection.setRemoteDescription(sessionDesc);
         }
+        this.log("RTC: Remote description set successfully");
+        for (let candidate of this._remoteCandidates) {
+          try {
+            await this._peerConnection?.addIceCandidate(candidate);
+            this.log("RTC: Added remote ICE candidate:", candidate);
+          } catch (error) {
+            this.error("RTC: Error adding remote ICE candidate:", error);
+          }
+        }
       } catch (error) {
-        console.error("RTC: Error setting remote description:", error);
+        this.error("RTC: Error setting remote description:", error);
       }
     } else if (message.c == "rtc-candidate") {
-      try {
-        if (this._peerConnection && message.candidate) {
-          await this._peerConnection.addIceCandidate(
-            //new RTCIceCandidate(message.candidate)
-            message.candidate
-          );
-        } else {
-          console.warn(
-            "RTC: Received candidate but peerConnection not ready or candidate missing"
-          );
-        }
-      } catch (error) {
+      this.log("RTC: candidate received", message);
+      if (this._peerConnection && message.candidate) {
+        this._remoteCandidates.push(message.candidate);
       }
     } else {
       this.onMessage(message);
     }
   }
   _onDocumentChange(name, op, target, path, value) {
-    if (this.debug) {
-      console.log("Document change:", name, op, target, path, value);
+    if (this.DEBUG) {
+      this.log("Document change:", name, op, target, path, value);
     }
     if (this.isPatched || !this.allowSync) {
       return;
@@ -770,12 +802,12 @@ var TopazCubeClient = class {
     }
   }
   _onRTCConnect() {
-    console.log("RTC: Connected");
+    this.log("RTC: Connected");
     this.send({ c: "test", message: "Hello RTC from client" });
   }
   _onRTCDisconnect() {
     this._webRTCConnected = false;
-    console.log("RTC: Disconnected");
+    this.log("RTC: Disconnected");
   }
   async _onRTCMessage(data) {
     this.stats.recRTC += data.byteLength;
@@ -787,6 +819,9 @@ var TopazCubeClient = class {
   }
   async _initializeWebRTC() {
     this._peerConnection = null;
+    this._candidates = [];
+    this._remoteCandidates = [];
+    this._offerSent = false;
     try {
       this._peerConnection = new RTCPeerConnection({
         iceServers: [
@@ -798,22 +833,31 @@ var TopazCubeClient = class {
       });
       this._peerConnection.onicecandidate = (event) => {
         if (event.candidate) {
-          this.send({
-            c: "rtc-candidate",
-            type: "ice-candidate",
-            candidate: event.candidate
-          });
+          this._candidates.push(event.candidate);
         } else {
+          this.log("RTC: ICE candidate gathering complete");
         }
       };
       this._peerConnection.onconnectionstatechange = () => {
         if (this._peerConnection && this._peerConnection.connectionState === "connected") {
           this._webRTCConnected = true;
+          this.log("RTC: Peer connection established!");
         } else if (this._peerConnection && (this._peerConnection.connectionState === "failed" || this._peerConnection.connectionState === "disconnected" || this._peerConnection.connectionState === "closed")) {
           this._webRTCConnected = false;
+          this.log("RTC: Peer connection closed or failed");
         }
       };
       this._peerConnection.onicegatheringstatechange = () => {
+        this.log(`RTC: ICE gathering state. _candidates:`, this._candidates.length, this._peerConnection?.iceGatheringState);
+        if (this._peerConnection?.iceGatheringState == "complete" && this._offerSent) {
+          for (let candidate of this._candidates) {
+            this.send({
+              c: "rtc-candidate",
+              type: "ice-candidate",
+              candidate
+            });
+          }
+        }
       };
       this._peerConnection.oniceconnectionstatechange = () => {
         if (this._peerConnection && (this._peerConnection.iceConnectionState === "connected" || this._peerConnection.iceConnectionState === "completed")) {
@@ -833,7 +877,7 @@ var TopazCubeClient = class {
         this._onRTCDisconnect();
       };
       this._dataChannel.onerror = (_error) => {
-        console.error("RTC: Client data channel error", _error);
+        this.error("RTC: Client data channel error", _error);
       };
       this._peerConnection.ondatachannel = (event) => {
         const dataChannel = event.channel;
@@ -864,17 +908,18 @@ var TopazCubeClient = class {
           sdp: ld.sdp
         };
         this.send(offerPayload);
+        this._offerSent = true;
       }
       setTimeout(() => {
         if (!this._webRTCConnected && this._peerConnection) {
           if (this._peerConnection.iceConnectionState === "failed") {
-            console.log("RTC: Attempting ICE restart");
+            this.log("RTC: Attempting ICE restart");
             this._restartIce();
           }
         }
       }, 5e3);
     } catch (error) {
-      console.error("RTC: error:", error);
+      this.error("RTC: error:", error);
     }
   }
   // Add this method to restart ICE if needed