@speckle/objectsender 1.0.0

package/dist/objectsender.js

@@ -0,0 +1,534 @@
+var ht = Object.defineProperty;
+var ut = (t, e, r) => e in t ? ht(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var u = (t, e, r) => (ut(t, typeof e != "symbol" ? e + "" : e, r), r), ft = (t, e, r) => {
+  if (!e.has(t))
+    throw TypeError("Cannot " + r);
+};
+var P = (t, e, r) => {
+  if (e.has(t))
+    throw TypeError("Cannot add the same private member more than once");
+  e instanceof WeakSet ? e.add(t) : e.set(t, r);
+};
+var y = (t, e, r) => (ft(t, e, "access private method"), r);
+function B(t) {
+  function e(T, _) {
+    return T << _ | T >>> 32 - _;
+  }
+  function r(T) {
+    let _ = "", v, C;
+    for (v = 7; v >= 0; v--)
+      C = T >>> v * 4 & 15, _ += C.toString(16);
+    return _;
+  }
+  function i(T) {
+    T = T.replace(/\r\n/g, `
+`);
+    let _ = "";
+    for (let v = 0; v < T.length; v++) {
+      const C = T.charCodeAt(v);
+      C < 128 ? _ += String.fromCharCode(C) : C > 127 && C < 2048 ? (_ += String.fromCharCode(C >> 6 | 192), _ += String.fromCharCode(C & 63 | 128)) : (_ += String.fromCharCode(C >> 12 | 224), _ += String.fromCharCode(C >> 6 & 63 | 128), _ += String.fromCharCode(C & 63 | 128));
+    }
+    return _;
+  }
+  let a, n, g;
+  const p = new Array(80);
+  let m = 1732584193, j = 4023233417, h = 2562383102, f = 271733878, S = 3285377520, l, s, o, c, d, b;
+  t = i(t);
+  const w = t.length, O = [];
+  for (n = 0; n < w - 3; n += 4)
+    g = t.charCodeAt(n) << 24 | t.charCodeAt(n + 1) << 16 | t.charCodeAt(n + 2) << 8 | t.charCodeAt(n + 3), O.push(g);
+  switch (w % 4) {
+    case 0:
+      n = 2147483648;
+      break;
+    case 1:
+      n = t.charCodeAt(w - 1) << 24 | 8388608;
+      break;
+    case 2:
+      n = t.charCodeAt(w - 2) << 24 | t.charCodeAt(w - 1) << 16 | 32768;
+      break;
+    case 3:
+      n = t.charCodeAt(w - 3) << 24 | t.charCodeAt(w - 2) << 16 | t.charCodeAt(w - 1) << 8 | 128;
+      break;
+  }
+  for (O.push(n); O.length % 16 !== 14; )
+    O.push(0);
+  for (O.push(w >>> 29), O.push(w << 3 & 4294967295), a = 0; a < O.length; a += 16) {
+    for (n = 0; n < 16; n++)
+      p[n] = O[a + n];
+    for (n = 16; n <= 79; n++)
+      p[n] = e(p[n - 3] ^ p[n - 8] ^ p[n - 14] ^ p[n - 16], 1);
+    for (l = m, s = j, o = h, c = f, d = S, n = 0; n <= 19; n++)
+      b = e(l, 5) + (s & o | ~s & c) + d + p[n] + 1518500249 & 4294967295, d = c, c = o, o = e(s, 30), s = l, l = b;
+    for (n = 20; n <= 39; n++)
+      b = e(l, 5) + (s ^ o ^ c) + d + p[n] + 1859775393 & 4294967295, d = c, c = o, o = e(s, 30), s = l, l = b;
+    for (n = 40; n <= 59; n++)
+      b = e(l, 5) + (s & o | s & c | o & c) + d + p[n] + 2400959708 & 4294967295, d = c, c = o, o = e(s, 30), s = l, l = b;
+    for (n = 60; n <= 79; n++)
+      b = e(l, 5) + (s ^ o ^ c) + d + p[n] + 3395469782 & 4294967295, d = c, c = o, o = e(s, 30), s = l, l = b;
+    m = m + l & 4294967295, j = j + s & 4294967295, h = h + o & 4294967295, f = f + c & 4294967295, S = S + d & 4294967295;
+  }
+  return (r(m) + r(j) + r(h) + r(f) + r(S)).toLowerCase().substring(0, 32);
+}
+var lt = typeof global == "object" && global && global.Object === Object && global, pt = typeof self == "object" && self && self.Object === Object && self, W = lt || pt || Function("return this")(), x = W.Symbol, rt = Object.prototype, dt = rt.hasOwnProperty, yt = rt.toString, F = x ? x.toStringTag : void 0;
+function gt(t) {
+  var e = dt.call(t, F), r = t[F];
+  try {
+    t[F] = void 0;
+    var i = !0;
+  } catch {
+  }
+  var a = yt.call(t);
+  return i && (e ? t[F] = r : delete t[F]), a;
+}
+var _t = Object.prototype, bt = _t.toString;
+function wt(t) {
+  return bt.call(t);
+}
+var Ct = "[object Null]", St = "[object Undefined]", Y = x ? x.toStringTag : void 0;
+function nt(t) {
+  return t == null ? t === void 0 ? St : Ct : Y && Y in Object(t) ? gt(t) : wt(t);
+}
+function it(t) {
+  return t != null && typeof t == "object";
+}
+var mt = "[object Symbol]";
+function J(t) {
+  return typeof t == "symbol" || it(t) && nt(t) == mt;
+}
+function Tt(t, e) {
+  for (var r = -1, i = t == null ? 0 : t.length, a = Array(i); ++r < i; )
+    a[r] = e(t[r], r, t);
+  return a;
+}
+var V = Array.isArray, vt = 1 / 0, Z = x ? x.prototype : void 0, Q = Z ? Z.toString : void 0;
+function at(t) {
+  if (typeof t == "string")
+    return t;
+  if (V(t))
+    return Tt(t, at) + "";
+  if (J(t))
+    return Q ? Q.call(t) : "";
+  var e = t + "";
+  return e == "0" && 1 / t == -vt ? "-0" : e;
+}
+function st(t) {
+  var e = typeof t;
+  return t != null && (e == "object" || e == "function");
+}
+var jt = "[object AsyncFunction]", Ot = "[object Function]", zt = "[object GeneratorFunction]", $t = "[object Proxy]";
+function At(t) {
+  if (!st(t))
+    return !1;
+  var e = nt(t);
+  return e == Ot || e == zt || e == jt || e == $t;
+}
+var K = W["__core-js_shared__"], tt = function() {
+  var t = /[^.]+$/.exec(K && K.keys && K.keys.IE_PROTO || "");
+  return t ? "Symbol(src)_1." + t : "";
+}();
+function kt(t) {
+  return !!tt && tt in t;
+}
+var Pt = Function.prototype, It = Pt.toString;
+function xt(t) {
+  if (t != null) {
+    try {
+      return It.call(t);
+    } catch {
+    }
+    try {
+      return t + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var Et = /[\\^$.*+?()[\]{}|]/g, Ft = /^\[object .+?Constructor\]$/, Dt = Function.prototype, Lt = Object.prototype, Nt = Dt.toString, Ht = Lt.hasOwnProperty, Ut = RegExp(
+  "^" + Nt.call(Ht).replace(Et, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function Mt(t) {
+  if (!st(t) || kt(t))
+    return !1;
+  var e = At(t) ? Ut : Ft;
+  return e.test(xt(t));
+}
+function Rt(t, e) {
+  return t == null ? void 0 : t[e];
+}
+function ot(t, e) {
+  var r = Rt(t, e);
+  return Mt(r) ? r : void 0;
+}
+function Gt(t, e) {
+  return t === e || t !== t && e !== e;
+}
+var Bt = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, Kt = /^\w*$/;
+function qt(t, e) {
+  if (V(t))
+    return !1;
+  var r = typeof t;
+  return r == "number" || r == "symbol" || r == "boolean" || t == null || J(t) ? !0 : Kt.test(t) || !Bt.test(t) || e != null && t in Object(e);
+}
+var N = ot(Object, "create");
+function Wt() {
+  this.__data__ = N ? N(null) : {}, this.size = 0;
+}
+function Jt(t) {
+  var e = this.has(t) && delete this.__data__[t];
+  return this.size -= e ? 1 : 0, e;
+}
+var Vt = "__lodash_hash_undefined__", Xt = Object.prototype, Yt = Xt.hasOwnProperty;
+function Zt(t) {
+  var e = this.__data__;
+  if (N) {
+    var r = e[t];
+    return r === Vt ? void 0 : r;
+  }
+  return Yt.call(e, t) ? e[t] : void 0;
+}
+var Qt = Object.prototype, te = Qt.hasOwnProperty;
+function ee(t) {
+  var e = this.__data__;
+  return N ? e[t] !== void 0 : te.call(e, t);
+}
+var re = "__lodash_hash_undefined__";
+function ne(t, e) {
+  var r = this.__data__;
+  return this.size += this.has(t) ? 0 : 1, r[t] = N && e === void 0 ? re : e, this;
+}
+function A(t) {
+  var e = -1, r = t == null ? 0 : t.length;
+  for (this.clear(); ++e < r; ) {
+    var i = t[e];
+    this.set(i[0], i[1]);
+  }
+}
+A.prototype.clear = Wt;
+A.prototype.delete = Jt;
+A.prototype.get = Zt;
+A.prototype.has = ee;
+A.prototype.set = ne;
+function ie() {
+  this.__data__ = [], this.size = 0;
+}
+function R(t, e) {
+  for (var r = t.length; r--; )
+    if (Gt(t[r][0], e))
+      return r;
+  return -1;
+}
+var ae = Array.prototype, se = ae.splice;
+function oe(t) {
+  var e = this.__data__, r = R(e, t);
+  if (r < 0)
+    return !1;
+  var i = e.length - 1;
+  return r == i ? e.pop() : se.call(e, r, 1), --this.size, !0;
+}
+function ce(t) {
+  var e = this.__data__, r = R(e, t);
+  return r < 0 ? void 0 : e[r][1];
+}
+function he(t) {
+  return R(this.__data__, t) > -1;
+}
+function ue(t, e) {
+  var r = this.__data__, i = R(r, t);
+  return i < 0 ? (++this.size, r.push([t, e])) : r[i][1] = e, this;
+}
+function E(t) {
+  var e = -1, r = t == null ? 0 : t.length;
+  for (this.clear(); ++e < r; ) {
+    var i = t[e];
+    this.set(i[0], i[1]);
+  }
+}
+E.prototype.clear = ie;
+E.prototype.delete = oe;
+E.prototype.get = ce;
+E.prototype.has = he;
+E.prototype.set = ue;
+var fe = ot(W, "Map");
+function le() {
+  this.size = 0, this.__data__ = {
+    hash: new A(),
+    map: new (fe || E)(),
+    string: new A()
+  };
+}
+function pe(t) {
+  var e = typeof t;
+  return e == "string" || e == "number" || e == "symbol" || e == "boolean" ? t !== "__proto__" : t === null;
+}
+function G(t, e) {
+  var r = t.__data__;
+  return pe(e) ? r[typeof e == "string" ? "string" : "hash"] : r.map;
+}
+function de(t) {
+  var e = G(this, t).delete(t);
+  return this.size -= e ? 1 : 0, e;
+}
+function ye(t) {
+  return G(this, t).get(t);
+}
+function ge(t) {
+  return G(this, t).has(t);
+}
+function _e(t, e) {
+  var r = G(this, t), i = r.size;
+  return r.set(t, e), this.size += r.size == i ? 0 : 1, this;
+}
+function k(t) {
+  var e = -1, r = t == null ? 0 : t.length;
+  for (this.clear(); ++e < r; ) {
+    var i = t[e];
+    this.set(i[0], i[1]);
+  }
+}
+k.prototype.clear = le;
+k.prototype.delete = de;
+k.prototype.get = ye;
+k.prototype.has = ge;
+k.prototype.set = _e;
+var be = "Expected a function";
+function X(t, e) {
+  if (typeof t != "function" || e != null && typeof e != "function")
+    throw new TypeError(be);
+  var r = function() {
+    var i = arguments, a = e ? e.apply(this, i) : i[0], n = r.cache;
+    if (n.has(a))
+      return n.get(a);
+    var g = t.apply(this, i);
+    return r.cache = n.set(a, g) || n, g;
+  };
+  return r.cache = new (X.Cache || k)(), r;
+}
+X.Cache = k;
+var we = 500;
+function Ce(t) {
+  var e = X(t, function(i) {
+    return r.size === we && r.clear(), i;
+  }), r = e.cache;
+  return e;
+}
+var Se = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, me = /\\(\\)?/g, Te = Ce(function(t) {
+  var e = [];
+  return t.charCodeAt(0) === 46 && e.push(""), t.replace(Se, function(r, i, a, n) {
+    e.push(a ? n.replace(me, "$1") : i || r);
+  }), e;
+});
+function ve(t) {
+  return t == null ? "" : at(t);
+}
+function je(t, e) {
+  return V(t) ? t : qt(t, e) ? [t] : Te(ve(t));
+}
+var Oe = 1 / 0;
+function ze(t) {
+  if (typeof t == "string" || J(t))
+    return t;
+  var e = t + "";
+  return e == "0" && 1 / t == -Oe ? "-0" : e;
+}
+function $e(t, e) {
+  e = je(e, t);
+  for (var r = 0, i = e.length; t != null && r < i; )
+    t = t[ze(e[r++])];
+  return r && r == i ? t : void 0;
+}
+function Ae(t, e, r) {
+  var i = t == null ? void 0 : $e(t, e);
+  return i === void 0 ? r : i;
+}
+const ke = (t) => it(t) && !!Ae(t, "speckle_type");
+var z, D, $, L, I, U, H, q, M, ct;
+class Pe {
+  constructor(e, r = 1e3, i = B) {
+    P(this, z);
+    P(this, $);
+    P(this, I);
+    P(this, H);
+    P(this, M);
+    u(this, "chunkSize");
+    u(this, "detachLineage");
+    u(this, "lineage");
+    u(this, "familyTree");
+    u(this, "closureTable");
+    u(this, "transport");
+    u(this, "uniqueId");
+    u(this, "hashingFunction");
+    this.chunkSize = r, this.detachLineage = [!0], this.lineage = [], this.familyTree = {}, this.closureTable = {}, this.transport = e, this.uniqueId = 0, this.hashingFunction = i || B;
+  }
+  async write(e) {
+    return await y(this, z, D).call(this, e, !0);
+  }
+  dispose() {
+    this.detachLineage = [], this.lineage = [], this.familyTree = {}, this.closureTable = {}, this.transport = null;
+  }
+}
+z = new WeakSet(), D = async function(e, r) {
+  const i = `${this.uniqueId++}-obj`;
+  this.lineage.push(i);
+  const a = { speckle_type: e.speckle_type || "Base" };
+  for (const h in e) {
+    const f = e[h];
+    if (!f || h === "id" || h.startsWith("_"))
+      continue;
+    if (typeof f != "object") {
+      a[h] = f;
+      continue;
+    }
+    const S = h.startsWith("@"), l = Array.isArray(f), s = l ? h.match(/^@\((\d*)\)/) : !1;
+    if (l && s && f.length !== 0 && typeof f[0] != "object") {
+      const o = s[1] !== "" ? parseInt(s[1]) : this.chunkSize, c = [];
+      let d = new et(), b = 0;
+      for (const w of f)
+        b === o && (c.push(await y(this, H, q).call(this, d)), d = new et(), b = 0), d.data.push(w), b++;
+      d.data.length !== 0 && c.push(await y(this, H, q).call(this, d)), a[h.replace(s[0], "")] = c;
+      continue;
+    }
+    if (f.speckle_type) {
+      const o = await y(this, $, L).call(this, {
+        value: f,
+        isDetached: S
+      });
+      a[h] = S ? y(this, I, U).call(this, o.id) : o;
+      continue;
+    }
+    a[h] = await y(this, $, L).call(this, {
+      value: f,
+      isDetached: S
+    });
+  }
+  const n = this.detachLineage.pop(), g = this.lineage.pop();
+  if (this.familyTree[g]) {
+    const h = {};
+    Object.entries(this.familyTree[g]).forEach(([f, S]) => {
+      h[f] = S - this.detachLineage.length;
+    }), a.totalChildrenCount = Object.keys(h).length, a.totalChildrenCount && (a.__closure = h);
+  }
+  const { hash: p, serializedObject: m, size: j } = y(this, M, ct).call(this, a);
+  return a.id = p, (n || r) && this.transport && await this.transport.write(m, j), r && this.transport && await this.transport.flush(), { hash: p, traversed: a };
+}, $ = new WeakSet(), L = async function({
+  value: e,
+  isDetached: r = !1
+}) {
+  if (typeof e != "object")
+    return e;
+  if (Array.isArray(e)) {
+    const i = e;
+    if (i.length === 0)
+      return e;
+    if (typeof i[0] != "object")
+      return i;
+    if (!r)
+      return Promise.all(
+        e.map(async (n) => await y(this, $, L).call(this, { value: n }))
+      );
+    const a = [];
+    for (const n of e)
+      if (ke(n)) {
+        this.detachLineage.push(r);
+        const { hash: g } = await y(this, z, D).call(this, n, !1);
+        a.push(y(this, I, U).call(this, g));
+      } else
+        a.push(await y(this, $, L).call(this, { value: n, isDetached: r }));
+    return a;
+  }
+  if (!e.speckle_type)
+    return e;
+  if (e.speckle_type)
+    return this.detachLineage.push(r), (await y(this, z, D).call(this, e, !1)).traversed;
+  throw new Error(`Unsupported type '${typeof e}': ${e}.`);
+}, I = new WeakSet(), U = function(e) {
+  return this.lineage.forEach((r) => {
+    this.familyTree[r] || (this.familyTree[r] = {}), (!this.familyTree[r][e] || this.familyTree[r][e] > this.detachLineage.length) && (this.familyTree[r][e] = this.detachLineage.length);
+  }), {
+    referencedId: e,
+    speckle_type: "reference"
+  };
+}, H = new WeakSet(), q = async function(e) {
+  this.detachLineage.push(!0);
+  const { hash: r } = await y(this, z, D).call(this, e, !1);
+  return y(this, I, U).call(this, r);
+}, M = new WeakSet(), ct = function(e) {
+  const r = JSON.stringify(e), i = this.hashingFunction(r), a = r.substring(0, 1) + `"id":"${i}",` + r.substring(1);
+  return {
+    hash: B(r),
+    serializedObject: a,
+    size: r.length
+    // approx, good enough as we're just limiting artificially batch sizes based on this
+  };
+};
+class et {
+  constructor() {
+    u(this, "speckle_type");
+    u(this, "data");
+    this.data = [], this.speckle_type = "Speckle.Core.Models.DataChunk";
+  }
+}
+class Ie {
+  constructor(e, r, i, a = 2e5) {
+    u(this, "buffer");
+    u(this, "maxSize");
+    u(this, "currSize");
+    u(this, "serverUrl");
+    u(this, "projectId");
+    u(this, "authToken");
+    this.maxSize = a, this.currSize = 0, this.serverUrl = e, this.projectId = r, this.authToken = i, this.buffer = [];
+  }
+  async write(e, r) {
+    this.buffer.push(e), this.currSize += r, !(this.currSize < this.maxSize) && await this.flush();
+  }
+  async flush() {
+    if (this.buffer.length === 0)
+      return;
+    const e = new FormData(), r = "[" + this.buffer.join(",") + "]";
+    e.append("object-batch", new Blob([r], { type: "application/json" }));
+    const i = new URL(`/objects/${this.projectId}`, this.serverUrl), a = await fetch(i, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.authToken}` },
+      body: e
+    });
+    if (a.status !== 201)
+      throw new Error(
+        `Unexpected error when sending data. Expected status 200, got ${a.status}`
+      );
+    this.buffer = [], this.currSize = 0;
+  }
+  dispose() {
+    this.buffer = [];
+  }
+}
+class Fe {
+  constructor(e) {
+    u(this, "speckle_type");
+    if (this.speckle_type = this.constructor.name, e)
+      for (const r in e)
+        this[r] = e[r];
+  }
+}
+const De = async (t, {
+  serverUrl: e = "https://app.speckle.systems",
+  projectId: r,
+  token: i,
+  logger: a = console
+}) => {
+  const n = performance.now();
+  a == null || a.log("Starting to send");
+  const g = new Ie(e, r, i), p = new Pe(g);
+  let m;
+  try {
+    m = await p.write(t);
+  } finally {
+    g.dispose(), p.dispose();
+  }
+  const j = performance.now();
+  return a.log(`Finished sending in ${(j - n) / 1e3}s.`), m;
+};
+export {
+  Fe as Base,
+  De as send
+};
+//# sourceMappingURL=objectsender.js.map