topazcube 0.1.31 → 0.1.35

package/dist/client.cjs

@@ -1,160 +1,8 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/client.ts
-var client_exports = {};
-__export(client_exports, {
-  default: () => TopazCubeClient
-});
-module.exports = __toCommonJS(client_exports);
-var import_fast_json_patch = require("fast-json-patch");
-
-// src/utils.ts
-var import_msgpackr = require("msgpackr");
-var import_msgpackr2 = require("msgpackr");
-var { ALWAYS } = import_msgpackr2.FLOAT32_OPTIONS;
-var packr = new import_msgpackr.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";
+const fastjsonpatch = require("fast-json-patch");
+const utils = require("./utils-CRhi1BDa.cjs");
+const glMatrix = require("gl-matrix");
+const browserFormat = "gzip";
 async function decompress(buffer) {
   if (typeof DecompressionStream !== "undefined") {
     try {
@@ -170,13 +18,9 @@ async function decompress(buffer) {
     throw new Error("DecompressionStream not supported");
   }
 }
-
-// src/client.ts
-var import_gl_matrix = require("gl-matrix");
-var TopazCubeClient = class {
+class TopazCubeClient {
   DEBUG = false;
   CYCLE = 200;
-  // update/patch rate in ms
   url = "";
   documents = {};
   autoReconnect = true;
@@ -194,13 +38,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;
@@ -209,9 +51,7 @@ var TopazCubeClient = class {
   _remoteCandidates = [];
   _offerSent = false;
   _dataChannel = null;
-  // our data channel
   _serverDataChannel = null;
-  // server data channel
   _webRTCConnected = false;
   isInterpolated = false;
   _lastInterpolate = Date.now();
@@ -226,11 +66,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
   }) {
@@ -256,7 +93,6 @@ var TopazCubeClient = class {
   error(...args) {
     console.error(...args);
   }
-  /*= UPDATE ===================================================================*/
   _startLoop() {
     if (this._loopiv) {
       clearInterval(this._loopiv);
@@ -302,53 +138,51 @@ 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;
           if (elapsed > 1e3) {
-            import_gl_matrix.vec3.copy(e.position, e._lpos2);
+            glMatrix.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);
+            glMatrix.vec3.lerp(this._dpos, e._lpos1, e._lpos2, alpha);
+            glMatrix.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 t1 = e._lrottime1;
+          const t2 = e._lrottime2;
           const interval = t2 - t1;
           const elapsed = now - t1;
           e.relapsed = elapsed;
           if (elapsed > 1e3) {
-            import_gl_matrix.quat.copy(e.rotation, e._lrot2);
+            glMatrix.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);
+            glMatrix.quat.slerp(this._drot, e._lrot1, e._lrot2, alpha);
+            glMatrix.quat.slerp(e.rotation, e.rotation, this._drot, 0.07);
             e._changed_rotation = now;
           }
         }
@@ -356,7 +190,6 @@ var TopazCubeClient = class {
     }
     this.isInterpolated = false;
   }
-  /*= CONNECTION ===============================================================*/
   subscribe(name) {
     this.documents[name] = {};
     this.send({ c: "sub", n: name });
@@ -374,11 +207,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 = utils.decode(decu);
       this._onMessage(message);
     };
     this.socket.onclose = (_event) => {
@@ -465,7 +298,6 @@ var TopazCubeClient = class {
       this.send({ c: "ping", ct: Date.now() });
     }
   }
-  /*= MESSAGES =================================================================*/
   onChange(_name, _doc, patch) {
   }
   onMessage(_message) {
@@ -475,7 +307,7 @@ var TopazCubeClient = class {
       return;
     }
     try {
-      let enc = encode(operation);
+      const enc = utils.encode(operation);
       this.stats.send += enc.byteLength;
       if (this.socket) {
         this.socket.send(enc);
@@ -485,19 +317,19 @@ 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;
       if (this.allowSync) {
-        this.documents[name] = reactive(
+        this.documents[name] = utils.reactive(
           name,
           this.documents[name],
           this._onDocumentChange.bind(this)
@@ -511,17 +343,17 @@ 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 = utils.msgop(op);
           try {
-            (0, import_fast_json_patch.applyOperation)(this.documents[name], dop);
+            fastjsonpatch.applyOperation(this.documents[name], dop);
           } catch (e) {
             this.warn("applyOperation failed for", name, "with op", dop, e);
           }
@@ -535,13 +367,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];
@@ -549,9 +381,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 = utils.decode(cdecu);
             this._onMessage(nmessage);
           } catch (error) {
             this.error("Error decoding chunks:", error);
@@ -562,13 +394,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");
           }
@@ -584,9 +416,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;
@@ -604,7 +436,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);
@@ -637,15 +469,15 @@ var TopazCubeClient = class {
     if (!this._documentChanges[name]) {
       this._documentChanges[name] = [];
     }
-    this._documentChanges[name].push(opmsg(op, target, path, value));
+    this._documentChanges[name].push(utils.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(),
@@ -662,17 +494,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;
     }
@@ -680,34 +512,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 = "" + utils.decode_uint32(pdata, offset);
           offset += 4;
-          let did = "" + decode_uint32(pdata, offset);
+          const did = "" + utils.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 = "" + utils.decode_uint32(pdata, offset);
           let e = entities[id];
           if (!e) {
             if (key == "position") {
@@ -731,11 +563,11 @@ var TopazCubeClient = class {
               e._lpostime1 = e._lpostime2;
             }
             e._lpostime2 = time;
-            e._lpos2[0] = origin[0] + decode_fp168(pdata, offset);
+            e._lpos2[0] = origin[0] + utils.decode_fp168(pdata, offset);
             offset += 3;
-            e._lpos2[1] = origin[1] + decode_fp168(pdata, offset);
+            e._lpos2[1] = origin[1] + utils.decode_fp168(pdata, offset);
             offset += 3;
-            e._lpos2[2] = origin[2] + decode_fp168(pdata, offset);
+            e._lpos2[2] = origin[2] + utils.decode_fp168(pdata, offset);
             offset += 3;
             if (!e.position) {
               e.position = [
@@ -756,15 +588,15 @@ var TopazCubeClient = class {
               e._lrottime1 = e._lrottime2;
             }
             e._lrottime2 = time;
-            e._lrot2[0] = decode_fp412(pdata, offset);
+            e._lrot2[0] = utils.decode_fp412(pdata, offset);
             offset += 2;
-            e._lrot2[1] = decode_fp412(pdata, offset);
+            e._lrot2[1] = utils.decode_fp412(pdata, offset);
             offset += 2;
-            e._lrot2[2] = decode_fp412(pdata, offset);
+            e._lrot2[2] = utils.decode_fp412(pdata, offset);
             offset += 2;
-            e._lrot2[3] = decode_fp412(pdata, offset);
+            e._lrot2[3] = utils.decode_fp412(pdata, offset);
             offset += 2;
-            import_gl_matrix.quat.normalize(e._lrot2, e._lrot2);
+            glMatrix.quat.normalize(e._lrot2, e._lrot2);
             if (!e.rotation) {
               e.rotation = [
                 e._lrot2[0],
@@ -784,11 +616,11 @@ var TopazCubeClient = class {
               e._lscatime1 = e._lscatime2;
             }
             e._lscatime2 = time;
-            e._lsca2[0] = decode_fp1616(pdata, offset);
+            e._lsca2[0] = utils.decode_fp1616(pdata, offset);
             offset += 4;
-            e._lsca2[1] = decode_fp1616(pdata, offset);
+            e._lsca2[1] = utils.decode_fp1616(pdata, offset);
             offset += 4;
-            e._lsca2[2] = decode_fp1616(pdata, offset);
+            e._lsca2[2] = utils.decode_fp1616(pdata, offset);
             offset += 4;
             if (!e.sca) {
               e.sca = [
@@ -802,10 +634,9 @@ var TopazCubeClient = class {
       }
     }
   }
-  /*= WEBRTC ===================================================================*/
   sendRTC(message) {
     if (this._dataChannel && this._dataChannel.readyState === "open") {
-      this._dataChannel.send(encode(message));
+      this._dataChannel.send(utils.encode(message));
     }
   }
   _onRTCConnect() {
@@ -818,10 +649,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 = utils.decode(decu);
     this._onMessage(message);
   }
   async _initializeWebRTC() {
@@ -857,7 +688,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",
@@ -907,7 +738,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",
@@ -929,7 +760,6 @@ var TopazCubeClient = class {
       this.error("RTC: error:", error);
     }
   }
-  // Add this method to restart ICE if needed
   async _restartIce() {
     try {
       const offerOptions = {
@@ -962,5 +792,6 @@ var TopazCubeClient = class {
     }
     this._webRTCConnected = false;
   }
-};
-//# sourceMappingURL=client.cjs.map
+}
+module.exports = TopazCubeClient;
+//# sourceMappingURL=client.cjs.map