topazcube 0.0.2 → 0.1.0

package/dist/topazcube-client.js

@@ -0,0 +1,481 @@
+import { applyOperation as L } from "fast-json-patch";
+import { FLOAT32_OPTIONS as b, Packr as F } from "msgpackr";
+import { vec3 as I, quat as R } from "gl-matrix";
+const { ALWAYS: M, DECIMAL_ROUND: Y, DECIMAL_FIT: $ } = b;
+let y = new F({
+  useFloat32: M
+});
+function S(o) {
+  return y.pack(o);
+}
+function w(o) {
+  return y.unpack(o);
+}
+function D(o, t, n, s = "", c = !1) {
+  if (t === null || typeof t != "object")
+    return t;
+  function r(l) {
+    let i = !0;
+    return l.startsWith("_") && (i = !1), c && c[l] && (i = !1), s == "/entities" && (i = !1), i;
+  }
+  for (const l in t)
+    r(l) && (t[l] = D(
+      o,
+      t[l],
+      n,
+      s + "/" + l,
+      c
+    ));
+  return new Proxy(t, {
+    get(l, i, h) {
+      return Reflect.get(l, i, h);
+    },
+    set(l, i, h) {
+      let _, d = s + "/" + String(i);
+      return r(i) ? (_ = D(o, h, n, d, c), n(o, "replace", l, d, _)) : _ = h, Reflect.set(l, i, _);
+    },
+    deleteProperty(l, i) {
+      let h = s + "/" + String(i);
+      return delete l[i], r(i) && n(o, "delete", l, h, null), !0;
+    }
+  });
+}
+function W(o) {
+  let t = {};
+  return o.o ? t.op = {
+    a: "add",
+    r: "remove",
+    d: "delete",
+    t: "test"
+  }[o.o] : t.op = "replace", t.path = o.p, t.value = o.v, t;
+}
+function B(o, t, n, s) {
+  let c = { p: n, v: s };
+  return o != "replace" && (c.o = {
+    add: "a",
+    remove: "r",
+    delete: "d",
+    test: "t"
+  }[o]), c;
+}
+function C(o, t = 0) {
+  let n = t;
+  return (o[n++] & 127) << 24 | o[n++] << 16 | o[n++] << 8 | o[n];
+}
+function U(o, t = 0) {
+  let n = t;
+  return o[n++] << 16 | o[n++] << 8 | o[n];
+}
+function O(o, t = 0) {
+  let n = t;
+  return o[n++] << 8 | o[n];
+}
+function g(o, t = 0) {
+  const n = (o[t] & 128) === 128 ? -256 : 256;
+  return o[t] &= 127, U(o, t) / n;
+}
+function T(o, t = 0) {
+  const n = (o[t] & 128) === 128 ? -65536 : 65536;
+  return o[t] &= 127, C(o, t) / n;
+}
+function u(o, t = 0) {
+  const n = (o[t] & 128) === 128 ? -4096 : 4096;
+  return o[t] &= 127, O(o, t) / n;
+}
+const E = "gzip";
+async function v(o) {
+  if (typeof DecompressionStream < "u")
+    try {
+      const t = new DecompressionStream(E);
+      return await new Response(
+        new Blob([o]).stream().pipeThrough(t)
+      ).arrayBuffer();
+    } catch {
+      return o;
+    }
+  else
+    throw new Error("DecompressionStream not supported");
+}
+class N {
+  constructor({
+    url: t,
+    // server url
+    autoReconnect: n = !0,
+    // auto reconnect on disconnect
+    allowSync: s = !0,
+    // allow sync on connect
+    allowWebRTC: c = !1
+  }) {
+    this.CYCLE = 200, this.url = "", this.documents = {}, this.autoReconnect = !0, this.allowSync = !0, this.allowWebRTC = !1, this.isConnected = !1, this.isConnecting = !1, this.isPatched = !1, this.stats = {
+      send: 0,
+      rec: 0,
+      recRTC: 0,
+      sendBps: 0,
+      recBps: 0,
+      recRTCBps: 0,
+      ping: 0,
+      stdiff: 0
+      // server time difference
+    }, this.lastFullState = 0, this.lastPatch = 0, this._chunks = {}, this.le = !0, this._documentChanges = {}, this.ID = 0, this.socket = null, this._peerConnection = null, this._dataChannel = null, this._serverDataChannel = null, this._webRTCConnected = null, this.isInterpolated = !1, this._lastInterpolate = Date.now(), this._lastUpdateId = {}, this._dpos = [0, 0, 0], this._drot = [0, 0, 0, 1], this._sca = [1, 1, 1], this._notifyChanges = !0, this._siv = null, this._loopiv = null, this._updateiv = null, this._pingiv = null, this.url = t, this.autoReconnect = n, this.allowSync = s, this.allowWebRTC = c, this.socket = null, this._startLoop(), console.log("Client initialized");
+  }
+  /*= UPDATE ===================================================================*/
+  _startLoop() {
+    this._loopiv && clearInterval(this._loopiv), this._loopiv = setInterval(() => {
+      this._loop();
+    }, this.CYCLE), this._siv = setInterval(() => {
+      this._updateStats();
+    }, 1e3), this._pingiv = setInterval(() => {
+      this._ping();
+    }, 1e4);
+  }
+  _loop() {
+    this.isConnected && this._sendPatches();
+  }
+  _updateStats() {
+    this.stats.recBps = this.stats.rec, this.stats.rec = 0, this.stats.recRTCBps = this.stats.recRTC, this.stats.recRTC = 0, this.stats.sendBps = this.stats.send, this.stats.send = 0;
+  }
+  _clear() {
+    this.stats.sendBps = 0, this.stats.recBps = 0, this.stats.recRTC = 0, this.stats.recRTCBps = 0, this.stats.send = 0, this.stats.rec = 0, this.ID = 0, this.documents = {}, this._documentChanges = {}, this._lastUpdateId = {}, this.lastFullState = 0, this.lastPatch = 0, this._lastInterpolate = 0, this.isPatched = !1, this.le = !0;
+  }
+  /*= INTERPOLATION ============================================================*/
+  // to be called in display rate (like 60fps) to interpolate .position, .rotation and .scale
+  interpolate() {
+    let t = Date.now(), n = t - this._lastInterpolate;
+    if (this._lastInterpolate = t, !(n <= 0 || n > 200)) {
+      this.isInterpolated = !0;
+      for (let s in this.documents) {
+        let r = this.documents[s].entities;
+        if (r)
+          for (let l in r) {
+            let i = r[l];
+            if (i._lpostime1 && i._lpostime2) {
+              let h = i._lpostime1;
+              const d = i._lpostime2 - h, a = t - h, f = Math.max(0, a / d);
+              I.lerp(this._dpos, i._lpos1, i._lpos2, f), I.lerp(i.position, i.position, this._dpos, 0.07), i._changed_position = t;
+            }
+            if (i._lrottime1 && i._lrottime2) {
+              let h = i._lrottime1;
+              const d = i._lrottime2 - h, a = t - h, f = Math.max(0, a / d);
+              R.slerp(this._drot, i._lrot1, i._lrot2, f), R.slerp(i.rotation, i.rotation, this._drot, 0.07), i._changed_rotation = t;
+            }
+          }
+      }
+      this.isInterpolated = !1;
+    }
+  }
+  /*= CONNECTION ===============================================================*/
+  subscribe(t) {
+    this.documents[t] = {}, this.send({ c: "sub", n: t });
+  }
+  unsubscribe(t) {
+    this.send({ c: "unsub", n: t }), delete this.documents[t];
+  }
+  connect() {
+    this.isConnecting || (this.isConnecting = !0, this._clear(), console.log("connecting..."), this.socket = new WebSocket(this.url), this.socket.onmessage = async (t) => {
+      let n = await t.data.arrayBuffer();
+      this.stats.rec += n.byteLength;
+      let s = await v(n), c = w(s);
+      this._onMessage(c);
+    }, this.socket.onclose = (t) => {
+      this._clear(), this.isConnected = !1, this.isConnecting = !1, this.lastFullState = 0, this.socket = null, this.onDisconnect(), this.allowWebRTC && this._destroyWebRTC(), this.autoReconnect && setTimeout(
+        () => {
+          this._reconnect();
+        },
+        500 + Math.random() * 500
+      );
+    }, this.socket.onerror = (t) => {
+      this._clear(), this.isConnected = !1, this.isConnecting = !1, this.lastFullState = 0, this.socket = null, this.onDisconnect(), this.allowWebRTC && this._destroyWebRTC(), this.autoReconnect && setTimeout(
+        () => {
+          this._reconnect();
+        },
+        500 + Math.random() * 500
+      );
+    }, this.socket.onopen = async (t) => {
+      this._clear(), this.isConnecting = !1, this.isConnected = !0, this.lastFullState = 0, this._ping(), this.onConnect(), this.allowWebRTC && await this._initializeWebRTC();
+    });
+  }
+  disconnect() {
+    this._clear(), this.isConnected = !1, this.isConnecting = !1, this.lastFullState = 0, this.socket.close(), this.socket = null;
+  }
+  destroy() {
+    this._clear(), this.autoReconnect = !1, this.disconnect(), this.socket = null, clearInterval(this._siv), clearInterval(this._loopiv);
+  }
+  onConnect() {
+  }
+  onDisconnect() {
+  }
+  _reconnect() {
+    this.isConnected || this.isConnecting || this.connect();
+  }
+  _ping() {
+    this.isConnected && this.send({ c: "ping", ct: Date.now() });
+  }
+  /*= MESSAGES =================================================================*/
+  onChange(t, n) {
+  }
+  onMessage(t) {
+  }
+  send(t) {
+    try {
+      let n = S(t);
+      this.stats.send += n.byteLength, this.socket.send(n);
+    } catch (n) {
+      console.error("send failed", n);
+    }
+  }
+  get document() {
+    let t = Object.keys(this.documents);
+    return this.documents[t[0]];
+  }
+  async _onMessage(t) {
+    let n = Date.now();
+    if (t.c == "full") {
+      console.log("full:", t);
+      let s = t.n, c = t.doc;
+      this.documents[s] = c, this._decodeFastChanges(t), this.isPatched = !1, this.allowSync && (this.documents[s] = D(
+        s,
+        this.documents[s],
+        this._onDocumentChange.bind(this)
+      )), this.isPatched = !1, this.lastFullState = t.t, this.le = t.le, this._notifyChanges && this.onChange(s, this.documents[s]);
+    } else if (t.c == "patch") {
+      this.lastPatch = t.t;
+      let s = t.n;
+      if (t.doc) {
+        this.isPatched = !0;
+        for (let c of t.doc) {
+          let r = W(c);
+          L(this.documents[s], r);
+        }
+        this.isPatched = !1;
+      }
+      this._notifyChanges && this.onChange(s, this.documents[s]);
+    } else if (t.c == "chunk") {
+      if (this._chunks[t.mid + "-" + t.seq] = t, t.last) {
+        let s = 0, c = t.ts, r = new Uint8Array(c);
+        for (const l in this._chunks) {
+          let i = this._chunks[l];
+          if (i.mid == t.mid) {
+            let h = i.ofs;
+            i.chs, r.set(new Uint8Array(i.data), h), s++, delete this._chunks[l];
+          }
+        }
+        if (s == t.seq + 1)
+          try {
+            let l = await v(r), i = w(l);
+            this._onMessage(i);
+          } catch (l) {
+            console.error("Error decoding chunks:", l);
+          }
+        else
+          console.warn("missing chunks", s, "of", t.seq + 1);
+      }
+    } else if (t.c == "fpatch") {
+      n = Date.now();
+      let s = t.n, c = !0;
+      if (!this._lastUpdateId[s])
+        this._lastUpdateId[s] = t.u;
+      else if (this._lastUpdateId[s] < t.u) {
+        let r = t.u - this._lastUpdateId[s] - 1;
+        r > 0 && console.warn("Lost " + r + " updates"), this._lastUpdateId[s] = t.u;
+      } else this._lastUpdateId[s] > t.u && (console.warn(`Received outdated update ID for document ${s}: ${t.u} < ${this._lastUpdateId[s]}`), c = !1);
+      c && this._decodeFastChanges(t);
+    } else if (t.c == "pong") {
+      this.ID = t.ID, n = Date.now();
+      let s = t.ct, c = n - s, r = t.t;
+      this.send({ c: "peng", ct: Date.now(), st: r }), this.stats.stdiff = r + c / 2 - n, this.stats.ping = c, console.log("ping", c, "ms", "stdiff", this.stats.stdiff, "ms");
+    } else if (t.c != "rtc-offer") if (t.c == "rtc-answer")
+      try {
+        const s = new RTCSessionDescription({
+          type: t.type,
+          sdp: t.sdp
+        });
+        await this._peerConnection.setRemoteDescription(s);
+      } catch (s) {
+        console.error("RTC: Error setting remote description:", s);
+      }
+    else if (t.c == "rtc-candidate")
+      try {
+        this._peerConnection && t.candidate ? await this._peerConnection.addIceCandidate(
+          new RTCIceCandidate(t.candidate)
+        ) : console.warn(
+          "RTC: Received candidate but peerConnection not ready or candidate missing"
+        );
+      } catch {
+      }
+    else
+      this.onMessage(t);
+  }
+  _onDocumentChange(t, n, s, c, r) {
+    this.isPatched || !this.allowSync || c.indexOf("/_") >= 0 || (this._documentChanges[t] || (this._documentChanges[t] = []), this._documentChanges[t].push(B(n, s, c, r)));
+  }
+  _sendPatches() {
+    for (let t in this._documentChanges) {
+      let n = this._documentChanges[t];
+      if (n.length == 0)
+        continue;
+      let s = {
+        n: t,
+        c: "sync",
+        ct: Date.now(),
+        p: null
+      };
+      n.length > 0 && (s.p = n), this.send(s), this._documentChanges[t].length = 0, this._notifyChanges && this.onChange(t, this.documents[t]);
+    }
+  }
+  _decodeFastChanges(t) {
+    let n = Date.now(), s = t.n, c = t.fdata;
+    if (!c)
+      return;
+    let r = this.documents[s];
+    if (!r)
+      return;
+    let l = r.entities;
+    if (!l)
+      return;
+    let i = this.documents[s].origin;
+    i || (i = [0, 0, 0]);
+    for (let h in c) {
+      let _ = c[h];
+      if (_.dict) {
+        let d = _.pdata, a = _.dict, f = {};
+        for (let p in a)
+          f[a[p]] = p;
+        let e = 0;
+        for (; e < d.byteLength; ) {
+          let p = "" + C(d, e);
+          e += 4;
+          let k = "" + C(d, e);
+          e += 4;
+          let m = l[p];
+          if (!m)
+            continue;
+          let P = f[k];
+          m[h] = P, m["_changed_" + h] = n;
+        }
+      } else {
+        let d = _.pdata, a = 0;
+        for (; a < d.byteLength; ) {
+          let f = "" + C(d, a), e = l[f];
+          if (!e) {
+            h == "position" ? a += 13 : h == "rotation" ? a += 8 : h == "scale" && (a += 16);
+            continue;
+          }
+          a += 4, h == "position" ? (e._lpos2 ? (e._lpos1[0] = e._lpos2[0], e._lpos1[1] = e._lpos2[1], e._lpos1[2] = e._lpos2[2], e._lpostime1 = e._lpostime2) : (e._lpos1 = [0, 0, 0], e._lpos2 = [0, 0, 0]), e._lpostime2 = n, e._lpos2[0] = i[0] + g(d, a), a += 3, e._lpos2[1] = i[1] + g(d, a), a += 3, e._lpos2[2] = i[2] + g(d, a), a += 3, e.position || (e.position = [
+            e._lpos2[0],
+            e._lpos2[1],
+            e._lpos2[2]
+          ])) : h == "rotation" ? (e._lrot2 ? (e._lrot1[0] = e._lrot2[0], e._lrot1[1] = e._lrot2[1], e._lrot1[2] = e._lrot2[2], e._lrot1[3] = e._lrot2[3], e._lrottime1 = e._lrottime2) : (e._lrot1 = [0, 0, 0, 1], e._lrot2 = [0, 0, 0, 1]), e._lrottime2 = n, e._lrot2[0] = u(d, a), a += 2, e._lrot2[1] = u(d, a), a += 2, e._lrot2[2] = u(d, a), a += 2, e._lrot2[3] = u(d, a), a += 2, R.normalize(e._lrot2, e._lrot2), e.rotation || (e.rotation = [
+            e._lrot2[0],
+            e._lrot2[1],
+            e._lrot2[2],
+            e._lrot2[3]
+          ])) : h == "scale" && (e._lsca2 ? (e._lsca1[0] = e._lsca2[0], e._lsca1[1] = e._lsca2[1], e._lsca1[2] = e._lsca2[2], e._lsca1[3] = e._lsca2[3], e._lscatime1 = e._lscatime2) : (e._lsca1 = [0, 0, 0, 1], e._lsca2 = [0, 0, 0, 1]), e._lscatime2 = n, e._lsca2[0] = T(d, a), a += 4, e._lsca2[1] = T(d, a), a += 4, e._lsca2[2] = T(d, a), a += 4, e.sca || (e.sca = [
+            e._lsca2[0],
+            e._lsca2[1],
+            e._lsca2[2]
+          ]));
+        }
+      }
+    }
+  }
+  /*= WEBRTC ===================================================================*/
+  sendRTC(t) {
+    this._dataChannel && this._dataChannel.readyState === "open" && this._dataChannel.send(S(t));
+  }
+  _onRTCConnect() {
+    console.log("RTC: Connected"), this.send({ c: "test", message: "Hello RTC from client" });
+  }
+  _onRTCDisconnect() {
+    this._webRTCConnected = !0, console.log("RTC: Disconnected");
+  }
+  async _onRTCMessage(t) {
+    this.stats.recRTC += t.byteLength;
+    let n = await v(t), s = w(n);
+    this._onMessage(s);
+  }
+  async _initializeWebRTC() {
+    this._peerConnection = null;
+    try {
+      this._peerConnection = new RTCPeerConnection({
+        iceServers: [
+          { urls: "stun:stun.l.google.com:19302" },
+          { urls: "stun:stun.cloudflare.com:3478" },
+          { urls: "stun:freestun.net:3478" }
+        ],
+        iceCandidatePoolSize: 10
+      }), this._peerConnection.onicecandidate = (r) => {
+        r.candidate && this.send({
+          c: "rtc-candidate",
+          type: "ice-candidate",
+          candidate: r.candidate
+        });
+      }, this._peerConnection.onconnectionstatechange = () => {
+        this._peerConnection.connectionState === "connected" ? this._webRTCConnected = !0 : (this._peerConnection.connectionState === "failed" || this._peerConnection.connectionState === "disconnected" || this._peerConnection.connectionState === "closed") && (this._webRTCConnected = !1);
+      }, this._peerConnection.onicegatheringstatechange = () => {
+      }, this._peerConnection.oniceconnectionstatechange = () => {
+        this._peerConnection.iceConnectionState === "connected" || this._peerConnection.iceConnectionState;
+      }, this._dataChannel = this._peerConnection.createDataChannel(
+        "clientchannel",
+        {
+          ordered: !0,
+          maxRetransmits: 1
+        }
+      ), this._dataChannel.onopen = () => {
+        this._onRTCConnect();
+      }, this._dataChannel.onclose = () => {
+        this._onRTCDisconnect();
+      }, this._dataChannel.onerror = (r) => {
+        console.error("RTC: Client data channel error", r);
+      }, this._peerConnection.ondatachannel = (r) => {
+        const l = r.channel;
+        this._serverDataChannel = l, l.onopen = () => {
+        }, l.onclose = () => {
+        }, l.onerror = (i) => {
+        }, l.onmessage = (i) => {
+          this._onRTCMessage(i.data);
+        };
+      };
+      const t = {
+        offerToReceiveAudio: !1,
+        offerToReceiveVideo: !1,
+        iceRestart: !0
+      }, n = await this._peerConnection.createOffer(t);
+      await this._peerConnection.setLocalDescription(n), await new Promise((r) => setTimeout(r, 100));
+      let s = this._peerConnection.localDescription;
+      const c = {
+        c: "rtc-offer",
+        type: s.type,
+        sdp: s.sdp
+      };
+      this.send(c), setTimeout(() => {
+        !this._webRTCConnected && this._peerConnection && this._peerConnection.iceConnectionState === "failed" && (console.log("RTC: Attempting ICE restart"), this._restartIce());
+      }, 5e3);
+    } catch (t) {
+      console.error("RTC: error:", t);
+    }
+  }
+  // Add this method to restart ICE if needed
+  async _restartIce() {
+    try {
+      const t = {
+        offerToReceiveAudio: !1,
+        offerToReceiveVideo: !1,
+        iceRestart: !0
+      }, n = await this._peerConnection.createOffer(t);
+      await this._peerConnection.setLocalDescription(n);
+      const s = {
+        c: "rtc-offer",
+        type: n.type,
+        sdp: n.sdp
+      };
+      this.send(s);
+    } catch {
+    }
+  }
+  async _destroyWebRTC() {
+    this._peerConnection && (this._peerConnection.dataChannel && this._peerConnection.dataChannel.close(), this._peerConnection.close(), this._peerConnection = null), this._dataChannel && (this._dataChannel.close(), this._dataChannel = null), this._webRTCConnected = !1;
+  }
+}
+export {
+  N as default
+};