topazcube 0.1.30 → 0.1.33

package/dist/client.js

@@ -1,136 +1,7 @@
-// src/client.ts
 import { applyOperation } from "fast-json-patch";
-
-// src/utils.ts
-import { Packr } from "msgpackr";
-import { FLOAT32_OPTIONS } from "msgpackr";
-var { ALWAYS } = FLOAT32_OPTIONS;
-var packr = new Packr({
-  useFloat32: ALWAYS
-});
-function encode(obj) {
-  return packr.pack(obj);
-}
-function decode(data) {
-  return packr.unpack(data);
-}
-function reactive(name, object, callback, path = "", excludedProperties = false) {
-  if (object === null || typeof object !== "object") {
-    return object;
-  }
-  function isReactive(p) {
-    let r = true;
-    if (p.startsWith("_")) {
-      r = false;
-    }
-    if (excludedProperties) {
-      if (excludedProperties[p]) {
-        r = false;
-      }
-    }
-    if (path == "/entities") {
-      r = false;
-    }
-    return r;
-  }
-  for (const property in object) {
-    if (isReactive(property)) {
-      object[property] = reactive(
-        name,
-        object[property],
-        callback,
-        path + "/" + property,
-        excludedProperties
-      );
-    } else {
-    }
-  }
-  return new Proxy(object, {
-    get(target, property, receiver) {
-      return Reflect.get(target, property, receiver);
-    },
-    set(target, property, value) {
-      let newvalue;
-      let pn = path + "/" + String(property);
-      if (isReactive(String(property))) {
-        newvalue = reactive(name, value, callback, pn, excludedProperties);
-        callback(name, "replace", target, pn, newvalue);
-      } else {
-        newvalue = value;
-      }
-      return Reflect.set(target, property, newvalue);
-    },
-    deleteProperty(target, property) {
-      let pn = path + "/" + String(property);
-      if (isReactive(String(property))) {
-        callback(name, "remove", target, pn, null);
-      }
-      delete target[property];
-      return true;
-    }
-  });
-}
-function msgop(op) {
-  let nop = {};
-  if (!op.o) {
-    nop.op = "replace";
-  } else {
-    nop.op = {
-      a: "add",
-      r: "remove",
-      d: "delete",
-      t: "test"
-    }[op.o];
-  }
-  nop.path = op.p;
-  nop.value = op.v;
-  return nop;
-}
-function opmsg(op, target, path, value) {
-  let c = { p: path, v: value };
-  if (op != "replace") {
-    c.o = {
-      add: "a",
-      remove: "r",
-      delete: "d",
-      test: "t"
-    }[op];
-  }
-  return c;
-}
-function decode_uint32(byteArray, offset = 0) {
-  let p = offset;
-  return (byteArray[p++] & 127) << 24 | byteArray[p++] << 16 | byteArray[p++] << 8 | byteArray[p];
-}
-function decode_uint24(byteArray, offset = 0) {
-  let p = offset;
-  return byteArray[p++] << 16 | byteArray[p++] << 8 | byteArray[p];
-}
-function decode_uint16(byteArray, offset = 0) {
-  let p = offset;
-  return byteArray[p++] << 8 | byteArray[p];
-}
-function decode_fp168(byteArray, offset = 0) {
-  const divider = (byteArray[offset] & 128) === 128 ? -256 : 256;
-  byteArray[offset] &= 127;
-  const fp = decode_uint24(byteArray, offset);
-  return fp / divider;
-}
-function decode_fp1616(byteArray, offset = 0) {
-  const divider = (byteArray[offset] & 128) === 128 ? -65536 : 65536;
-  byteArray[offset] &= 127;
-  const fp = decode_uint32(byteArray, offset);
-  return fp / divider;
-}
-function decode_fp412(byteArray, offset = 0) {
-  const divider = (byteArray[offset] & 128) === 128 ? -4096 : 4096;
-  byteArray[offset] &= 127;
-  const fp = decode_uint16(byteArray, offset);
-  return fp / divider;
-}
-
-// src/compress-browser.ts
-var browserFormat = "gzip";
+import { d as decode, e as encode, r as reactive, m as msgop, o as opmsg, a as decode_uint32, b as decode_fp168, c as decode_fp412, f as decode_fp1616 } from "./utils-D7tXt6-2.js";
+import { vec3, quat } from "gl-matrix";
+const browserFormat = "gzip";
 async function decompress(buffer) {
   if (typeof DecompressionStream !== "undefined") {
     try {
@@ -146,13 +17,9 @@ async function decompress(buffer) {
     throw new Error("DecompressionStream not supported");
   }
 }
-
-// src/client.ts
-import { vec3, quat } from "gl-matrix";
-var TopazCubeClient = class {
+class TopazCubeClient {
   DEBUG = false;
   CYCLE = 200;
-  // update/patch rate in ms
   url = "";
   documents = {};
   autoReconnect = true;
@@ -170,13 +37,11 @@ var TopazCubeClient = class {
     recRTCBps: 0,
     ping: 0,
     stdiff: 0
-    // server time difference
   };
   lastFullState = 0;
   lastPatch = 0;
   _chunks = {};
   le = true;
-  // Server is little endian
   _documentChanges = {};
   ID = 0;
   socket = null;
@@ -185,9 +50,7 @@ var TopazCubeClient = class {
   _remoteCandidates = [];
   _offerSent = false;
   _dataChannel = null;
-  // our data channel
   _serverDataChannel = null;
-  // server data channel
   _webRTCConnected = false;
   isInterpolated = false;
   _lastInterpolate = Date.now();
@@ -202,11 +65,8 @@ var TopazCubeClient = class {
   _pingiv = null;
   constructor({
     url,
-    // server url
     autoReconnect = true,
-    // auto reconnect on disconnect
     allowSync = true,
-    // allow sync on connect
     allowWebRTC = false,
     DEBUG = false
   }) {
@@ -232,7 +92,6 @@ var TopazCubeClient = class {
   error(...args) {
     console.error(...args);
   }
-  /*= UPDATE ===================================================================*/
   _startLoop() {
     if (this._loopiv) {
       clearInterval(this._loopiv);
@@ -278,27 +137,25 @@ var TopazCubeClient = class {
     this.isPatched = false;
     this.le = true;
   }
-  /*= INTERPOLATION ============================================================*/
-  // to be called in display rate (like 60fps) to interpolate .position, .rotation and .scale
   interpolate() {
-    let now = Date.now();
-    let dt = now - this._lastInterpolate;
+    const now = Date.now();
+    const dt = now - this._lastInterpolate;
     this._lastInterpolate = now;
     if (dt <= 0 || dt > 200) {
       return;
     }
     this.isInterpolated = true;
-    for (let name in this.documents) {
-      let doc = this.documents[name];
-      let entities = doc?.entities;
+    for (const name in this.documents) {
+      const doc = this.documents[name];
+      const entities = doc?.entities;
       if (!entities) {
         continue;
       }
-      for (let id in entities) {
-        let e = entities[id];
+      for (const id in entities) {
+        const e = entities[id];
         if (e._lpostime1 && e._lpostime2) {
-          let t1 = e._lpostime1;
-          let t2 = e._lpostime2;
+          const t1 = e._lpostime1;
+          const t2 = e._lpostime2;
           const interval = t2 - t1;
           const elapsed = now - t1;
           e.pelapsed = elapsed;
@@ -313,8 +170,8 @@ var TopazCubeClient = class {
           }
         }
         if (e._lrottime1 && e._lrottime2) {
-          let t1 = e._lrottime1;
-          let t2 = e._lrottime2;
+          const t1 = e._lrottime1;
+          const t2 = e._lrottime2;
           const interval = t2 - t1;
           const elapsed = now - t1;
           e.relapsed = elapsed;
@@ -332,7 +189,6 @@ var TopazCubeClient = class {
     }
     this.isInterpolated = false;
   }
-  /*= CONNECTION ===============================================================*/
   subscribe(name) {
     this.documents[name] = {};
     this.send({ c: "sub", n: name });
@@ -350,11 +206,11 @@ var TopazCubeClient = class {
     this.log("connecting...");
     this.socket = new WebSocket(this.url);
     this.socket.onmessage = async (event) => {
-      let buffer = await event.data.arrayBuffer();
+      const buffer = await event.data.arrayBuffer();
       this.stats.rec += buffer.byteLength;
-      let dec = await decompress(buffer);
-      let decu = new Uint8Array(dec);
-      let message = decode(decu);
+      const dec = await decompress(buffer);
+      const decu = new Uint8Array(dec);
+      const message = decode(decu);
       this._onMessage(message);
     };
     this.socket.onclose = (_event) => {
@@ -441,14 +297,16 @@ var TopazCubeClient = class {
       this.send({ c: "ping", ct: Date.now() });
     }
   }
-  /*= MESSAGES =================================================================*/
   onChange(_name, _doc, patch) {
   }
   onMessage(_message) {
   }
   send(operation) {
+    if (!this.isConnected) {
+      return;
+    }
     try {
-      let enc = encode(operation);
+      const enc = encode(operation);
       this.stats.send += enc.byteLength;
       if (this.socket) {
         this.socket.send(enc);
@@ -458,14 +316,14 @@ var TopazCubeClient = class {
     }
   }
   get document() {
-    let names = "" + Object.keys(this.documents);
+    const names = "" + Object.keys(this.documents);
     return this.documents["" + names[0]];
   }
   async _onMessage(message) {
     let time = Date.now();
     if (message.c == "full") {
-      let name = "" + message.n;
-      let doc = message.doc;
+      const name = "" + message.n;
+      const doc = message.doc;
       this.documents[name] = doc;
       this._decodeFastChanges(message);
       this.isPatched = false;
@@ -484,15 +342,15 @@ var TopazCubeClient = class {
       }
     } else if (message.c == "patch") {
       this.lastPatch = message.t;
-      let name = message.n;
+      const name = message.n;
       if (!this.documents[name]) {
         this.warn("Patch for unknown document", name);
         return;
       }
       if (message.doc) {
         this.isPatched = true;
-        for (let op of message.doc) {
-          let dop = msgop(op);
+        for (const op of message.doc) {
+          const dop = msgop(op);
           try {
             applyOperation(this.documents[name], dop);
           } catch (e) {
@@ -508,13 +366,13 @@ var TopazCubeClient = class {
       this._chunks[message.mid + "-" + message.seq] = message;
       if (message.last) {
         let cfound = 0;
-        let ts = message.ts;
-        let cdata = new Uint8Array(ts);
+        const ts = message.ts;
+        const cdata = new Uint8Array(ts);
         for (const cid in this._chunks) {
-          let chunk = this._chunks[cid];
+          const chunk = this._chunks[cid];
           if (chunk.mid == message.mid) {
-            let offset = chunk.ofs;
-            let _csize = chunk.chs;
+            const offset = chunk.ofs;
+            chunk.chs;
             cdata.set(new Uint8Array(chunk.data), offset);
             cfound++;
             delete this._chunks[cid];
@@ -522,9 +380,9 @@ var TopazCubeClient = class {
         }
         if (cfound == message.seq + 1) {
           try {
-            let cdec = await decompress(cdata);
-            let cdecu = new Uint8Array(cdec);
-            let nmessage = decode(cdecu);
+            const cdec = await decompress(cdata);
+            const cdecu = new Uint8Array(cdec);
+            const nmessage = decode(cdecu);
             this._onMessage(nmessage);
           } catch (error) {
             this.error("Error decoding chunks:", error);
@@ -535,13 +393,13 @@ var TopazCubeClient = class {
       }
     } else if (message.c == "fpatch") {
       time = Date.now();
-      let name = message.n;
+      const name = message.n;
       let doPatch = true;
       if (!this._lastUpdateId[name]) {
         this._lastUpdateId[name] = message.u;
       } else {
         if (this._lastUpdateId[name] < message.u) {
-          let lp = message.u - this._lastUpdateId[name] - 1;
+          const lp = message.u - this._lastUpdateId[name] - 1;
           if (lp > 0) {
             this.warn("Lost " + lp + " updates");
           }
@@ -557,9 +415,9 @@ var TopazCubeClient = class {
     } else if (message.c == "pong") {
       this.ID = message.ID;
       time = Date.now();
-      let lastct = message.ct;
-      let ping = time - lastct;
-      let stime = message.t;
+      const lastct = message.ct;
+      const ping = time - lastct;
+      const stime = message.t;
       this.send({ c: "peng", ct: Date.now(), st: stime });
       this.stats.stdiff = stime + ping / 2 - time;
       this.stats.ping = ping;
@@ -577,7 +435,7 @@ var TopazCubeClient = class {
           await this._peerConnection.setRemoteDescription(sessionDesc);
         }
         this.log("RTC: Remote description set successfully");
-        for (let candidate of this._remoteCandidates) {
+        for (const candidate of this._remoteCandidates) {
           try {
             await this._peerConnection?.addIceCandidate(candidate);
             this.log("RTC: Added remote ICE candidate:", candidate);
@@ -613,12 +471,12 @@ var TopazCubeClient = class {
     this._documentChanges[name].push(opmsg(op, target, path, value));
   }
   _sendPatches() {
-    for (let name in this._documentChanges) {
-      let dc = this._documentChanges[name];
+    for (const name in this._documentChanges) {
+      const dc = this._documentChanges[name];
       if (!dc || dc.length == 0) {
         continue;
       }
-      let record = {
+      const record = {
         n: name,
         c: "sync",
         ct: Date.now(),
@@ -635,17 +493,17 @@ var TopazCubeClient = class {
     }
   }
   _decodeFastChanges(message) {
-    let time = Date.now();
-    let name = message.n;
-    let fdata = message.fdata;
+    const time = Date.now();
+    const name = message.n;
+    const fdata = message.fdata;
     if (!fdata) {
       return;
     }
-    let doc = this.documents[name];
+    const doc = this.documents[name];
     if (!doc) {
       return;
     }
-    let entities = doc.entities;
+    const entities = doc.entities;
     if (!entities) {
       return;
     }
@@ -653,34 +511,34 @@ var TopazCubeClient = class {
     if (!origin) {
       origin = [0, 0, 0];
     }
-    for (let key in fdata) {
-      let changes = fdata[key];
+    for (const key in fdata) {
+      const changes = fdata[key];
       if (changes.dict) {
-        let pdata = changes.pdata;
-        let dict = changes.dict;
-        let rdict = {};
-        for (let key2 in dict) {
+        const pdata = changes.pdata;
+        const dict = changes.dict;
+        const rdict = {};
+        for (const key2 in dict) {
           rdict[dict[key2]] = key2;
         }
         let offset = 0;
         while (offset < pdata.byteLength) {
-          let id = "" + decode_uint32(pdata, offset);
+          const id = "" + decode_uint32(pdata, offset);
           offset += 4;
-          let did = "" + decode_uint32(pdata, offset);
+          const did = "" + decode_uint32(pdata, offset);
           offset += 4;
-          let e = entities[id];
+          const e = entities[id];
           if (!e) {
             continue;
           }
-          let value = rdict[did];
+          const value = rdict[did];
           e[key] = value;
           e["_changed_" + key] = time;
         }
       } else {
-        let pdata = changes.pdata;
+        const pdata = changes.pdata;
         let offset = 0;
         while (offset < pdata.byteLength) {
-          let id = "" + decode_uint32(pdata, offset);
+          const id = "" + decode_uint32(pdata, offset);
           let e = entities[id];
           if (!e) {
             if (key == "position") {
@@ -775,7 +633,6 @@ var TopazCubeClient = class {
       }
     }
   }
-  /*= WEBRTC ===================================================================*/
   sendRTC(message) {
     if (this._dataChannel && this._dataChannel.readyState === "open") {
       this._dataChannel.send(encode(message));
@@ -791,10 +648,10 @@ var TopazCubeClient = class {
   }
   async _onRTCMessage(data) {
     this.stats.recRTC += data.byteLength;
-    let datau = new Uint8Array(data);
-    let dec = await decompress(datau);
-    let decu = new Uint8Array(dec);
-    let message = decode(decu);
+    const datau = new Uint8Array(data);
+    const dec = await decompress(datau);
+    const decu = new Uint8Array(dec);
+    const message = decode(decu);
     this._onMessage(message);
   }
   async _initializeWebRTC() {
@@ -830,7 +687,7 @@ var TopazCubeClient = class {
       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) {
+          for (const candidate of this._candidates) {
             this.send({
               c: "rtc-candidate",
               type: "ice-candidate",
@@ -880,7 +737,7 @@ var TopazCubeClient = class {
       const offer = await this._peerConnection.createOffer(offerOptions);
       await this._peerConnection.setLocalDescription(offer);
       await new Promise((resolve) => setTimeout(resolve, 100));
-      let ld = this._peerConnection.localDescription;
+      const ld = this._peerConnection.localDescription;
       if (ld) {
         const offerPayload = {
           c: "rtc-offer",
@@ -902,7 +759,6 @@ var TopazCubeClient = class {
       this.error("RTC: error:", error);
     }
   }
-  // Add this method to restart ICE if needed
   async _restartIce() {
     try {
       const offerOptions = {
@@ -935,8 +791,8 @@ var TopazCubeClient = class {
     }
     this._webRTCConnected = false;
   }
-};
+}
 export {
   TopazCubeClient as default
 };
-//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map