topazcube 0.1.11 → 0.1.13

package/dist/server.cjs

@@ -364,13 +364,22 @@ var TopazCubeServer = class {
   };
   _wss = null;
   _exited = false;
+  log(...args) {
+    this.log(this.name + ":", ...args);
+  }
+  warn(...args) {
+    this.warn(this.name + ":", ...args);
+  }
+  error(...args) {
+    this.error(this.name + ":", ...args);
+  }
   constructor({
     name = "TopazCubeServer",
     cycle = 100,
     port = 8799,
     useHttps = false,
     key = "./cert/key.pem",
-    cert = "./cert/fullchain.pem",
+    cert = "./cert/cert.pem",
     MongoUrl = "mongodb://localhost:27017",
     database = "topazcube",
     collection = "documents",
@@ -407,10 +416,10 @@ var TopazCubeServer = class {
       }).listen(this.port);
       this._wss = new import_ws.WebSocketServer({ server: httpsServer });
       httpsServer = null;
-      console.log(this.name + " running on HTTPS port " + this.port);
+      this.log(this.name + " running on HTTPS port " + this.port);
     } else {
       this._wss = new import_ws.WebSocketServer({ port: this.port });
-      console.log(this.name + " running on port " + this.port);
+      this.log(this.name + " running on port " + this.port);
     }
     this._wss.on("connection", (client) => {
       this._onConnected(client);
@@ -436,13 +445,13 @@ var TopazCubeServer = class {
         this._exitSignal("SIGINT");
         return;
       }
-      console.log(`Key pressed: ${key2}`);
+      this.log(`Key pressed: ${key2}`);
       if (key2 == "s") {
-        console.log("Saving all documents...");
+        this.log("Saving all documents...");
         this._saveAllDocuments();
       }
       if (key2 == "i") {
-        console.log(
+        this.log(
           `Server: ${this.name}, Clients: ${this.clients.length}, Documents: ${Object.keys(this.documents).length}`
         );
       }
@@ -565,7 +574,7 @@ var TopazCubeServer = class {
       patchTime = t2 - t1;
       this.stats.tPatch.push(patchTime);
       if (this.allowFastPatch) {
-        console.log(`update ${this.update} dt:${dtms}ms RTC:${this.stats._sendRTCUpdate}bytes, tUpdate: ${updateTime}ms, tPatch: ${patchTime}ms`);
+        this.log(`update ${this.update} dt:${dtms}ms RTC:${this.stats._sendRTCUpdate}bytes, tUpdate: ${updateTime}ms, tPatch: ${patchTime}ms`);
       }
       this.stats._sendRTCUpdate = 0;
     }
@@ -607,7 +616,7 @@ var TopazCubeServer = class {
     client.subscribed = {};
     client.dataChannel = null;
     client.peerConnection = null;
-    console.log("client connected", client.ID);
+    this.log("client connected", client.ID);
     this.clients.push(client);
     client.on("error", () => {
       this._onError(client, arguments);
@@ -677,7 +686,7 @@ var TopazCubeServer = class {
     }
   }
   _onError(client, args) {
-    console.error("onError:", args);
+    this.error("onError:", args);
   }
   _onDisconnected(client) {
     if (client.dataChannel) {
@@ -686,7 +695,7 @@ var TopazCubeServer = class {
     if (client.peerConnection) {
       client.peerConnection.close();
     }
-    console.log("client disconnected");
+    this.log("client disconnected");
     let index = this.clients.indexOf(client);
     if (index !== -1) {
       this.clients.splice(index, 1);
@@ -703,7 +712,7 @@ var TopazCubeServer = class {
       }
       let t3 = Date.now();
       if (data.length > 4096) {
-        console.log(`Big message ${dl} -> ${data.length} (${(100 * data.length / dl).toFixed()}%) encoding:${t2 - t1}ms compression:${t3 - t1}ms`);
+        this.log(`Big message ${dl} -> ${data.length} (${(100 * data.length / dl).toFixed()}%) encoding:${t2 - t1}ms compression:${t3 - t1}ms`);
       }
       this.stats.send += data.byteLength;
       if (this.simulateLatency) {
@@ -714,7 +723,7 @@ var TopazCubeServer = class {
         client.send(data);
       }
     } catch (e) {
-      console.error("Error sending message:", e, message);
+      this.error("Error sending message:", e, message);
     }
   }
   async broadcast(message, clients = false) {
@@ -821,7 +830,7 @@ var TopazCubeServer = class {
         }
       }
     }
-    console.log("--------------------------------------------------");
+    this.log("--------------------------------------------------");
     for (let key in hasChanges) {
       if (hasChanges[key]) {
         let size = parseInt("" + count["" + key]);
@@ -923,7 +932,7 @@ var TopazCubeServer = class {
             fdata: changes
           };
           let t3 = Date.now();
-          console.log(`_sendPatches: ${name} encode_changes: ${t2 - t1}ms broadcast:${t3 - t2}ms`);
+          this.log(`_sendPatches: ${name} encode_changes: ${t2 - t1}ms broadcast:${t3 - t2}ms`);
         }
       }
     }
@@ -949,7 +958,7 @@ var TopazCubeServer = class {
   /*= WEBRTC ===================================================================*/
   /*
     async _processOffer(client: ClientType, data: any): Promise<void> {
-      //console.log("RTC: Offer received", data);
+      //this.log("RTC: Offer received", data);
       const peerConnection = new wrtc.RTCPeerConnection({
         iceServers: [
           { urls: 'stun:stun.l.google.com:19302' },
@@ -963,43 +972,43 @@ var TopazCubeServer = class {
   
       peerConnection.onicecandidate = (event: any) => {
         if (event.candidate) {
-          //console.log("RTC: ICE candidate generated", event.candidate.candidate.substring(0, 50) + "...");
+          //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 {
-          //console.log("RTC: ICE candidate gathering complete");
+          //this.log("RTC: ICE candidate gathering complete");
         }
       }
   
       peerConnection.onconnectionstatechange = () => {
-        //console.log(`RTC: Connection state changed: ${peerConnection.connectionState}`);
+        //this.log(`RTC: Connection state changed: ${peerConnection.connectionState}`);
         if (peerConnection.connectionState === 'connected') {
           client.webRTCConnected = true
-          console.log(`RTC: Connection established with client ${client.ID}`)
+          this.log(`RTC: Connection established with client ${client.ID}`)
         } else if (
           peerConnection.connectionState === 'failed' ||
           peerConnection.connectionState === 'disconnected' ||
           peerConnection.connectionState === 'closed'
         ) {
           client.webRTCConnected = false
-          console.log(`RTC: Connection failed or closed with client ${client.ID}`)
+          this.log(`RTC: Connection failed or closed with client ${client.ID}`)
         }
       }
   
       peerConnection.onicegatheringstatechange = () => {
-        //console.log(`RTC: ICE gathering state: ${peerConnection.iceGatheringState}`);
+        //this.log(`RTC: ICE gathering state: ${peerConnection.iceGatheringState}`);
       }
   
       peerConnection.oniceconnectionstatechange = () => {
-        //console.log(`RTC: ICE connection state: ${peerConnection.iceConnectionState}`);
+        //this.log(`RTC: ICE connection state: ${peerConnection.iceConnectionState}`);
         if (
           peerConnection.iceConnectionState === 'connected' ||
           peerConnection.iceConnectionState === 'completed'
         ) {
-          //console.log(`RTC: ICE connection established with client ${client.ID}`);
+          //this.log(`RTC: ICE connection established with client ${client.ID}`);
         }
       }
   
@@ -1007,7 +1016,7 @@ var TopazCubeServer = class {
         await peerConnection.setRemoteDescription(
           new wrtc.RTCSessionDescription(data)
         )
-        //console.log("RTC: Remote description set successfully");
+        //this.log("RTC: Remote description set successfully");
   
         client.dataChannel = peerConnection.createDataChannel('serverchannel', {
           ordered: true,
@@ -1015,13 +1024,13 @@ var TopazCubeServer = class {
         })
   
         client.dataChannel.onopen = () => {
-          //console.log(`RTC: Data channel opened for client ${client.ID}`);
+          //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) {
-            console.error(
+            this.error(
               `RTC: Error sending test message to client ${client.ID}`,
               e
             )
@@ -1029,23 +1038,23 @@ var TopazCubeServer = class {
         }
   
         client.dataChannel.onclose = () => {
-          console.log(`RTC: Data channel closed for client ${client.ID}`)
+          this.log(`RTC: Data channel closed for client ${client.ID}`)
         }
   
         client.dataChannel.onerror = (error: Event) => {
-          console.error(`RTC: Data channel error for client ${client.ID}:`, error)
+          this.error(`RTC: Data channel error for client ${client.ID}:`, error)
         }
   
         client.dataChannel.onmessage = (event: MessageEvent) => {
           try {
             const data = decode(event.data)
-            console.log(
+            this.log(
               `RTC: Data channel message from client ${client.ID}:`,
               data
             )
             //this.onMessage(client, data);
           } catch (error) {
-            console.error(
+            this.error(
               `RTC: Error decoding message from client ${client.ID}:`,
               error
             )
@@ -1056,14 +1065,14 @@ var TopazCubeServer = class {
         const answer = await peerConnection.createAnswer()
         await peerConnection.setLocalDescription(answer)
   
-        //console.log(`RTC: Sending answer to client ${client.ID}`);
+        //this.log(`RTC: Sending answer to client ${client.ID}`);
         this.send(client, {
           c: 'rtc-answer',
           type: answer.type,
           sdp: answer.sdp,
         })
       } catch (error) {
-        console.error(
+        this.error(
           `RTC: Error processing offer from client ${client.ID}:`,
           error
         )
@@ -1071,19 +1080,19 @@ var TopazCubeServer = class {
     }
   
     async _processICECandidate(client: ClientType, data: any): Promise<void> {
-      //console.log(`RTC: Processing ICE candidate from client ${client.ID}`);
+      //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)
           )
-          //console.log(`RTC: ICE candidate added successfully for client ${client.ID}`);
+          //this.log(`RTC: ICE candidate added successfully for client ${client.ID}`);
         } else {
-          //console.warn(`RTC: Cannot add ICE candidate for client ${client.ID} - peerConnection not ready or candidate missing`);
+          //this.warn(`RTC: Cannot add ICE candidate for client ${client.ID} - peerConnection not ready or candidate missing`);
         }
       } catch (error) {
-        console.error(`RTC: Error adding ICE candidate for client ${client.ID}`)
+        this.error(`RTC: Error adding ICE candidate for client ${client.ID}`)
       }
     }
   
@@ -1133,7 +1142,7 @@ var TopazCubeServer = class {
   
   
       if (data.length > 16384) {
-        console.log(`BroadcastRTC message ${dl} -> ${data.length} (${(100.0 * data.length / dl).toFixed()}%) encoding:${t2 - t1}ms compression:${t3 - t1}ms`)
+        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)
@@ -1163,7 +1172,7 @@ var TopazCubeServer = class {
       let packages: Uint8Array[]
       if (data.byteLength > 65535) {
         const now = Date.now()
-        console.warn(`RTC: Message too large: ${data.byteLength} bytes`)
+        this.warn(`RTC: Message too large: ${data.byteLength} bytes`)
         // Split the message into smaller packages
         packages = [];
         let offset = 0;
@@ -1191,10 +1200,10 @@ var TopazCubeServer = class {
           seq++;
         }
   
-        console.log(`RTC: Large message split into ${packages.length} packages`);
+        this.log(`RTC: Large message split into ${packages.length} packages`);
       } else {
         packages = [data]
-        console.log(`RTC: Message - ${data.byteLength} bytes`)
+        this.log(`RTC: Message - ${data.byteLength} bytes`)
       }
       return packages
     }
@@ -1217,16 +1226,16 @@ var TopazCubeServer = class {
     this.mongoClient = new import_mongodb.MongoClient(this.MongoUrl);
     try {
       await this.mongoClient.connect();
-      console.log("Connected to MongoDB");
+      this.log("Connected to MongoDB");
       const db = this.mongoClient.db(this.database);
       this.DB = db;
     } catch (error) {
-      console.error("Error connecting to MongoDB:", error);
+      this.error("Error connecting to MongoDB:", error);
       this.mongoClient = null;
     }
   }
   async _loadDocument(name) {
-    console.log(`Loading document '${name}' from MongoDB`);
+    this.log(`Loading document '${name}' from MongoDB`);
     if (this.DB) {
       try {
         const doc = await this.DB.collection(this.collection).findOne({
@@ -1237,10 +1246,10 @@ var TopazCubeServer = class {
           this.documents[name] = doc;
         }
       } catch (error) {
-        console.error("Error loading document from MongoDB:", error);
+        this.error("Error loading document from MongoDB:", error);
       }
     } else {
-      console.warn("MongoDB client not initialized. Document not loaded.");
+      this.warn("MongoDB client not initialized. Document not loaded.");
     }
   }
   async _saveDocument(name) {
@@ -1248,18 +1257,18 @@ var TopazCubeServer = class {
       try {
         const doc = this.documents[name];
         let newdoc = clonewo_(doc, "__");
-        console.log(`Saving document '${name}' to MongoDB`);
+        this.log(`Saving document '${name}' to MongoDB`);
         await this.DB.collection(this.collection).updateOne(
           { name },
           { $set: newdoc },
           { upsert: true }
         );
-        console.log("Document saved to MongoDB");
+        this.log("Document saved to MongoDB");
       } catch (error) {
-        console.error("Error saving document to MongoDB:", error);
+        this.error("Error saving document to MongoDB:", error);
       }
     } else {
-      console.warn("MongoDB client not initialized. Document not saved.");
+      this.warn("MongoDB client not initialized. Document not saved.");
     }
   }
   async _saveAllDocuments() {
@@ -1278,7 +1287,7 @@ var TopazCubeServer = class {
   /*= EXIT ===================================================================*/
   _exitSignal(signal) {
     if (!this._exited) {
-      console.log("\nEXIT: Caught interrupt signal " + signal);
+      this.log("\nEXIT: Caught interrupt signal " + signal);
       this._exited = true;
       clearInterval(this._loopiv);
       this.onBeforeExit();