topazcube 0.1.15 → 0.1.17

package/dist/server.js

@@ -88,9 +88,9 @@ function clonewo_(obj, excludeStart = "_") {
   }
   if (obj instanceof Map) {
     const mapClone = /* @__PURE__ */ new Map();
-    for (let [key, value] of obj) {
+    Array.from(obj.entries()).forEach(([key, value]) => {
       mapClone.set(clonewo_(key, excludeStart), clonewo_(value, excludeStart));
-    }
+    });
     return mapClone;
   }
   let clone;
@@ -247,6 +247,7 @@ import fastjsonpatch from "fast-json-patch";
 import { WebSocketServer } from "ws";
 import { MongoClient } from "mongodb";
 import { glMatrix } from "gl-matrix";
+import wrtc from "@roamhq/wrtc";
 glMatrix.setMatrixArrayType(Array);
 var fastPatchProperties = {
   "type": true,
@@ -291,6 +292,7 @@ var LITTLE_ENDIAN = (() => {
   new DataView(buffer).setInt16(0, 256, true);
   return new Int16Array(buffer)[0] === 256;
 })();
+var MAX_PACKAGE_SIZE = 65400;
 var TopazCubeServer = class {
   name = "TopazCubeServer";
   cycle = 100;
@@ -584,8 +586,8 @@ var TopazCubeServer = class {
     client.peerConnection = null;
     this.log("client connected", client.ID);
     this.clients.push(client);
-    client.on("error", () => {
-      this._onError(client, arguments);
+    client.on("error", (...args) => {
+      this._onError(client, args);
     });
     client.on("message", (message) => {
       let dec = decode(message);
@@ -922,258 +924,206 @@ var TopazCubeServer = class {
     e["__changed_" + property] = true;
   }
   /*= WEBRTC ===================================================================*/
-  /*
-    async _processOffer(client: ClientType, data: any): Promise<void> {
-      //this.log("RTC: Offer received", data);
-      const peerConnection = new wrtc.RTCPeerConnection({
-        iceServers: [
-          { urls: 'stun:stun.l.google.com:19302' },
-          { urls: 'stun:stun.cloudflare.com:3478' },
-          { urls: 'stun:freestun.net:3478' },
-        ],
-        iceCandidatePoolSize: 10,
-      })
-  
-      client.peerConnection = peerConnection
-  
-      peerConnection.onicecandidate = (event: any) => {
-        if (event.candidate) {
-          //this.log("RTC: ICE candidate generated", event.candidate.candidate.substring(0, 50) + "...");
-          this.send(client, {
-            c: 'rtc-candidate',
-            type: 'ice-candidate',
-            candidate: event.candidate, // .toJSON()
-          })
-        } else {
-          //this.log("RTC: ICE candidate gathering complete");
-        }
-      }
-  
-      peerConnection.onconnectionstatechange = () => {
-        //this.log(`RTC: Connection state changed: ${peerConnection.connectionState}`);
-        if (peerConnection.connectionState === 'connected') {
-          client.webRTCConnected = true
-          this.log(`RTC: Connection established with client ${client.ID}`)
-        } else if (
-          peerConnection.connectionState === 'failed' ||
-          peerConnection.connectionState === 'disconnected' ||
-          peerConnection.connectionState === 'closed'
-        ) {
-          client.webRTCConnected = false
-          this.log(`RTC: Connection failed or closed with client ${client.ID}`)
-        }
+  async _processOffer(client, data) {
+    const peerConnection = new wrtc.RTCPeerConnection({
+      iceServers: [
+        { urls: "stun:stun.l.google.com:19302" },
+        { urls: "stun:stun.cloudflare.com:3478" },
+        { urls: "stun:freestun.net:3478" }
+      ],
+      iceCandidatePoolSize: 10
+    });
+    client.peerConnection = peerConnection;
+    peerConnection.onicecandidate = (event) => {
+      if (event.candidate) {
+        this.send(client, {
+          c: "rtc-candidate",
+          type: "ice-candidate",
+          candidate: event.candidate
+          // .toJSON()
+        });
+      } else {
       }
-  
-      peerConnection.onicegatheringstatechange = () => {
-        //this.log(`RTC: ICE gathering state: ${peerConnection.iceGatheringState}`);
+    };
+    peerConnection.onconnectionstatechange = () => {
+      if (peerConnection.connectionState === "connected") {
+        client.webRTCConnected = true;
+        this.log(`RTC: Connection established with client ${client.ID}`);
+      } else if (peerConnection.connectionState === "failed" || peerConnection.connectionState === "disconnected" || peerConnection.connectionState === "closed") {
+        client.webRTCConnected = false;
+        this.log(`RTC: Connection failed or closed with client ${client.ID}`);
       }
-  
-      peerConnection.oniceconnectionstatechange = () => {
-        //this.log(`RTC: ICE connection state: ${peerConnection.iceConnectionState}`);
-        if (
-          peerConnection.iceConnectionState === 'connected' ||
-          peerConnection.iceConnectionState === 'completed'
-        ) {
-          //this.log(`RTC: ICE connection established with client ${client.ID}`);
-        }
+    };
+    peerConnection.onicegatheringstatechange = () => {
+    };
+    peerConnection.oniceconnectionstatechange = () => {
+      if (peerConnection.iceConnectionState === "connected" || peerConnection.iceConnectionState === "completed") {
       }
-  
-      try {
-        await peerConnection.setRemoteDescription(
-          new wrtc.RTCSessionDescription(data)
-        )
-        //this.log("RTC: Remote description set successfully");
-  
-        client.dataChannel = peerConnection.createDataChannel('serverchannel', {
-          ordered: true,
-          maxRetransmits: 1,
-        })
-  
-        client.dataChannel.onopen = () => {
-          //this.log(`RTC: Data channel opened for client ${client.ID}`);
-          // Try sending a test message
-          try {
-            const testData = { c: 'test', message: 'Hello WebRTC' }
-            this.sendRTC(client, testData)
-          } catch (e) {
-            this.error(
-              `RTC: Error sending test message to client ${client.ID}`,
-              e
-            )
-          }
-        }
-  
-        client.dataChannel.onclose = () => {
-          this.log(`RTC: Data channel closed for client ${client.ID}`)
-        }
-  
-        client.dataChannel.onerror = (error: Event) => {
-          this.error(`RTC: Data channel error for client ${client.ID}:`, error)
+    };
+    try {
+      await peerConnection.setRemoteDescription(
+        new wrtc.RTCSessionDescription(data)
+      );
+      client.dataChannel = peerConnection.createDataChannel("serverchannel", {
+        ordered: true,
+        maxRetransmits: 1
+      });
+      client.dataChannel.onopen = () => {
+        try {
+          const testData = { c: "test", message: "Hello WebRTC" };
+          this.sendRTC(client, testData);
+        } catch (e) {
+          this.error(
+            `RTC: Error sending test message to client ${client.ID}`,
+            e
+          );
         }
-  
-        client.dataChannel.onmessage = (event: MessageEvent) => {
-          try {
-            const data = decode(event.data)
-            this.log(
-              `RTC: Data channel message from client ${client.ID}:`,
-              data
-            )
-            //this.onMessage(client, data);
-          } catch (error) {
-            this.error(
-              `RTC: Error decoding message from client ${client.ID}:`,
-              error
-            )
-          }
+      };
+      client.dataChannel.onclose = () => {
+        this.log(`RTC: Data channel closed for client ${client.ID}`);
+      };
+      client.dataChannel.onerror = (error) => {
+        this.error(`RTC: Data channel error for client ${client.ID}:`, error);
+      };
+      client.dataChannel.onmessage = (event) => {
+        try {
+          const data2 = decode(event.data);
+          this.log(
+            `RTC: Data channel message from client ${client.ID}:`,
+            data2
+          );
+        } catch (error) {
+          this.error(
+            `RTC: Error decoding message from client ${client.ID}:`,
+            error
+          );
         }
-  
-        // Create and send answer
-        const answer = await peerConnection.createAnswer()
-        await peerConnection.setLocalDescription(answer)
-  
-        //this.log(`RTC: Sending answer to client ${client.ID}`);
-        this.send(client, {
-          c: 'rtc-answer',
-          type: answer.type,
-          sdp: answer.sdp,
-        })
-      } catch (error) {
-        this.error(
-          `RTC: Error processing offer from client ${client.ID}:`,
-          error
-        )
+      };
+      const answer = await peerConnection.createAnswer();
+      await peerConnection.setLocalDescription(answer);
+      this.send(client, {
+        c: "rtc-answer",
+        type: answer.type,
+        sdp: answer.sdp
+      });
+    } catch (error) {
+      this.error(
+        `RTC: Error processing offer from client ${client.ID}:`,
+        error
+      );
+    }
+  }
+  async _processICECandidate(client, data) {
+    try {
+      if (client.peerConnection && data.candidate) {
+        await client.peerConnection.addIceCandidate(
+          data.candidate
+          //new wrtc.RTCIceCandidate(data.candidate)
+        );
+      } else {
       }
+    } catch (error) {
+      this.error(`RTC: Error adding ICE candidate for client ${client.ID}`);
     }
-  
-    async _processICECandidate(client: ClientType, data: any): Promise<void> {
-      //this.log(`RTC: Processing ICE candidate from client ${client.ID}`);
-      try {
-        if (client.peerConnection && data.candidate) {
-          await client.peerConnection.addIceCandidate(
-            data.candidate
-            //new wrtc.RTCIceCandidate(data.candidate)
-          )
-          //this.log(`RTC: ICE candidate added successfully for client ${client.ID}`);
-        } else {
-          //this.warn(`RTC: Cannot add ICE candidate for client ${client.ID} - peerConnection not ready or candidate missing`);
+  }
+  _clientRTCOpen(client) {
+    return client.dataChannel !== null && client.dataChannel !== void 0 && client.dataChannel.readyState === "open";
+  }
+  async sendRTC(client, message) {
+    let data = encode(message);
+    if (this.allowCompression) {
+      data = await compress(data);
+    }
+    this.stats.sendRTC += data.byteLength;
+    this.stats._sendRTCUpdate += data.byteLength;
+    let packages = this._splitRTCMessage(data);
+    if (this.simulateLatency) {
+      setTimeout(() => {
+        if (this._clientRTCOpen(client)) {
+          packages.forEach((p) => {
+            client.dataChannel.send(p);
+          });
         }
-      } catch (error) {
-        this.error(`RTC: Error adding ICE candidate for client ${client.ID}`)
+      }, this.simulateLatency);
+    } else {
+      if (this._clientRTCOpen(client)) {
+        packages.forEach((p) => {
+          client.dataChannel.send(p);
+        });
       }
     }
-  
-    _clientRTCOpen(client: ClientType): boolean {
-      return client.dataChannel !== null && client.dataChannel !== undefined && client.dataChannel.readyState === 'open'
+  }
+  async broadcastRTC(message, clients = []) {
+    if (clients.length == 0) {
+      clients = this.clients;
     }
-  
-    async sendRTC(client: ClientType, message: any): Promise<void> {
-      let data = encode(message)
-      if (this.allowCompression) {
-        data = await compress(data)
-      }
-      this.stats.sendRTC += data.byteLength
-      this.stats._sendRTCUpdate += data.byteLength
-  
-      let packages = this._splitRTCMessage(data)
-  
+    let t1 = Date.now();
+    let data = encode(message);
+    let dl = data.byteLength;
+    let t2 = Date.now();
+    if (this.allowCompression) {
+      data = await compress(data);
+    }
+    let t3 = Date.now();
+    if (data.length > 16384) {
+      this.log(`BroadcastRTC message ${dl} -> ${data.length} (${(100 * data.length / dl).toFixed()}%) encoding:${t2 - t1}ms compression:${t3 - t1}ms`);
+    }
+    let packages = this._splitRTCMessage(data);
+    for (let client of this.clients) {
+      this.stats.sendRTC += data.byteLength;
+      this.stats._sendRTCUpdate += data.byteLength;
       if (this.simulateLatency) {
         setTimeout(() => {
-          if (this._clientRTCOpen(client)) {
+          if (client.dataChannel && client.dataChannel.readyState === "open") {
             packages.forEach((p) => {
-              client.dataChannel!.send(p)
-            })
+              client?.dataChannel?.send(p);
+            });
           }
-        }, this.simulateLatency)
+        }, this.simulateLatency);
       } else {
-        if (this._clientRTCOpen(client)) {
+        if (client.dataChannel && client.dataChannel.readyState === "open") {
           packages.forEach((p) => {
-            client.dataChannel!.send(p)
-          })
+            client?.dataChannel?.send(p);
+          });
         }
       }
     }
-  
-    async broadcastRTC(message: any, clients: ClientType[] = []): Promise<void> {
-      if (clients.length == 0) {
-        clients = this.clients
-      }
-      let t1 = Date.now()
-      let data = encode(message)
-      let dl = data.byteLength
-      let t2 = Date.now()
-      if (this.allowCompression) {
-        data = await compress(data)
-      }
-      let t3 = Date.now()
-  
-  
-      if (data.length > 16384) {
-        this.log(`BroadcastRTC message ${dl} -> ${data.length} (${(100.0 * data.length / dl).toFixed()}%) encoding:${t2 - t1}ms compression:${t3 - t1}ms`)
-      }
-  
-      let packages = this._splitRTCMessage(data)
-  
-      for (let client of this.clients) {
-        this.stats.sendRTC += data.byteLength
-        this.stats._sendRTCUpdate += data.byteLength
-        if (this.simulateLatency) {
-          setTimeout(() => {
-            if (client.dataChannel && client.dataChannel.readyState === 'open') {
-              packages.forEach((p) => {
-                client?.dataChannel?.send(p)
-              })
-            }
-          }, this.simulateLatency)
-        } else {
-          if (client.dataChannel && client.dataChannel.readyState === 'open') {
-            packages.forEach((p) => {
-              client?.dataChannel?.send(p)
-            })
-          }
-        }
-      }
-    }
-  
-    _splitRTCMessage(data: Uint8Array): Uint8Array[] {
-      let packages: Uint8Array[]
-      if (data.byteLength > 65535) {
-        const now = Date.now()
-        this.warn(`RTC: Message too large: ${data.byteLength} bytes`)
-        // Split the message into smaller packages
-        packages = [];
-        let offset = 0;
-        let mid = this.update +'-'+ now
-        let seq = 0
-  
-        // Create subsequent packages if needed
-        while (offset < data.byteLength) {
-          const remaining = data.byteLength - offset;
-          const chunkSize = Math.min(remaining, MAX_PACKAGE_SIZE);
-          const chunk = new Uint8Array(data.buffer, offset, chunkSize);
-          let cmessage = {
-            c: 'chunk',
-            t: now,
-            mid: mid,
-            seq: seq,
-            ofs: offset,
-            chs: chunkSize,
-            ts: data.byteLength,
-            data: chunk,
-            last: remaining <= MAX_PACKAGE_SIZE,
-          }
-          packages.push(encode(cmessage))
-          offset += chunkSize;
-          seq++;
-        }
-  
-        this.log(`RTC: Large message split into ${packages.length} packages`);
-      } else {
-        packages = [data]
-        this.log(`RTC: Message - ${data.byteLength} bytes`)
+  }
+  _splitRTCMessage(data) {
+    let packages;
+    if (data.byteLength > 65535) {
+      const now = Date.now();
+      this.warn(`RTC: Message too large: ${data.byteLength} bytes`);
+      packages = [];
+      let offset = 0;
+      let mid = this.update + "-" + now;
+      let seq = 0;
+      while (offset < data.byteLength) {
+        const remaining = data.byteLength - offset;
+        const chunkSize = Math.min(remaining, MAX_PACKAGE_SIZE);
+        const chunk = new Uint8Array(data.buffer, offset, chunkSize);
+        let cmessage = {
+          c: "chunk",
+          t: now,
+          mid,
+          seq,
+          ofs: offset,
+          chs: chunkSize,
+          ts: data.byteLength,
+          data: chunk,
+          last: remaining <= MAX_PACKAGE_SIZE
+        };
+        packages.push(encode(cmessage));
+        offset += chunkSize;
+        seq++;
       }
-      return packages
+      this.log(`RTC: Large message split into ${packages.length} packages`);
+    } else {
+      packages = [data];
+      this.log(`RTC: Message - ${data.byteLength} bytes`);
     }
-    */
+    return packages;
+  }
   /*= DATABASE =================================================================*/
   // properties (of the documents) that starts with __ are not saved to the database.
   // __properties are restored on hydration. (for example __physicsBody or __bigObject)