@stripchatdev/ext-helper 0.1.1 → 0.1.2

package/dist/ext-helper.js

@@ -1,323 +1,571 @@
-const M = (r) => !!r && typeof r == "object" && "protocol" in r && r.protocol === "iframe_pubsub" && "version" in r && r.version === "1.0", f = (r, e) => r, E = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var u;
-(function(r) {
-  r.Base32IncorrectEncoding = "B32_ENC_INVALID", r.DecodeTimeInvalidCharacter = "DEC_TIME_CHAR", r.DecodeTimeValueMalformed = "DEC_TIME_MALFORMED", r.EncodeTimeNegative = "ENC_TIME_NEG", r.EncodeTimeSizeExceeded = "ENC_TIME_SIZE_EXCEED", r.EncodeTimeValueMalformed = "ENC_TIME_MALFORMED", r.PRNGDetectFailure = "PRNG_DETECT", r.ULIDInvalid = "ULID_INVALID", r.Unexpected = "UNEXPECTED", r.UUIDInvalid = "UUID_INVALID";
-})(u || (u = {}));
-class d extends Error {
-  constructor(e, t) {
-    super(`${t} (${e})`), this.name = "ULIDError", this.code = e;
+const T = (e) => !!e && typeof e == "object" && "protocol" in e && e.protocol === "iframe_pubsub" && "version" in e && e.version === "1.0", y = (e, t) => e, w = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var l;
+(function(e) {
+  e.Base32IncorrectEncoding = "B32_ENC_INVALID", e.DecodeTimeInvalidCharacter = "DEC_TIME_CHAR", e.DecodeTimeValueMalformed = "DEC_TIME_MALFORMED", e.EncodeTimeNegative = "ENC_TIME_NEG", e.EncodeTimeSizeExceeded = "ENC_TIME_SIZE_EXCEED", e.EncodeTimeValueMalformed = "ENC_TIME_MALFORMED", e.PRNGDetectFailure = "PRNG_DETECT", e.ULIDInvalid = "ULID_INVALID", e.Unexpected = "UNEXPECTED", e.UUIDInvalid = "UUID_INVALID";
+})(l || (l = {}));
+class f extends Error {
+  constructor(t, r) {
+    super(`${r} (${t})`), this.name = "ULIDError", this.code = t;
   }
 }
-function m(r) {
-  const e = Math.floor(r() * 32) % 32;
-  return E.charAt(e);
+function P(e) {
+  const t = Math.floor(e() * 32) % 32;
+  return w.charAt(t);
 }
-function R(r) {
-  const e = y(), t = e && (e.crypto || e.msCrypto) || null;
-  if (typeof (t == null ? void 0 : t.getRandomValues) == "function")
+function _(e) {
+  const t = H(), r = t && (t.crypto || t.msCrypto) || null;
+  if (typeof (r == null ? void 0 : r.getRandomValues) == "function")
     return () => {
-      const n = new Uint8Array(1);
-      return t.getRandomValues(n), n[0] / 255;
+      const s = new Uint8Array(1);
+      return r.getRandomValues(s), s[0] / 255;
     };
-  if (typeof (t == null ? void 0 : t.randomBytes) == "function")
-    return () => t.randomBytes(1).readUInt8() / 255;
-  throw new d(u.PRNGDetectFailure, "Failed to find a reliable PRNG");
+  if (typeof (r == null ? void 0 : r.randomBytes) == "function")
+    return () => r.randomBytes(1).readUInt8() / 255;
+  throw new f(l.PRNGDetectFailure, "Failed to find a reliable PRNG");
 }
-function y() {
-  return I() ? self : typeof window < "u" ? window : typeof global < "u" ? global : typeof globalThis < "u" ? globalThis : null;
+function H() {
+  return O() ? self : typeof window < "u" ? window : typeof global < "u" ? global : typeof globalThis < "u" ? globalThis : null;
 }
-function N(r, e) {
-  let t = "";
-  for (; r > 0; r--)
-    t = m(e) + t;
-  return t;
+function q(e, t) {
+  let r = "";
+  for (; e > 0; e--)
+    r = P(t) + r;
+  return r;
 }
-function v(r, e = 10) {
-  if (isNaN(r))
-    throw new d(u.EncodeTimeValueMalformed, `Time must be a number: ${r}`);
-  if (r > 281474976710655)
-    throw new d(u.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${281474976710655}: ${r}`);
-  if (r < 0)
-    throw new d(u.EncodeTimeNegative, `Time must be positive: ${r}`);
-  if (Number.isInteger(r) === !1)
-    throw new d(u.EncodeTimeValueMalformed, `Time must be an integer: ${r}`);
-  let t, n = "";
-  for (let s = e; s > 0; s--)
-    t = r % 32, n = E.charAt(t) + n, r = (r - t) / 32;
-  return n;
+function L(e, t = 10) {
+  if (isNaN(e))
+    throw new f(l.EncodeTimeValueMalformed, `Time must be a number: ${e}`);
+  if (e > 281474976710655)
+    throw new f(l.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${281474976710655}: ${e}`);
+  if (e < 0)
+    throw new f(l.EncodeTimeNegative, `Time must be positive: ${e}`);
+  if (Number.isInteger(e) === !1)
+    throw new f(l.EncodeTimeValueMalformed, `Time must be an integer: ${e}`);
+  let r, s = "";
+  for (let n = t; n > 0; n--)
+    r = e % 32, s = w.charAt(r) + s, e = (e - r) / 32;
+  return s;
 }
-function I() {
+function O() {
   return typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope;
 }
-function p(r, e) {
-  const t = R(), n = Date.now();
-  return v(n, 10) + N(16, t);
+function g(e, t) {
+  const r = _(), s = Date.now();
+  return L(s, 10) + q(16, r);
 }
-const _ = ({ seq: r, uniqId: e }) => (t) => ({
+const S = ({ seq: e, uniqId: t }) => (r) => ({
   ...{
     protocol: "iframe_pubsub",
     version: "1.0",
-    id: e(),
-    seq: r(),
+    id: t(),
+    seq: e(),
     timestamp: Date.now()
   },
-  ...t
-}), b = _({
-  uniqId: () => p(),
-  seq: () => p()
+  ...r
+}), m = S({
+  uniqId: () => g(),
+  seq: () => g()
 });
-class T {
-  constructor(e) {
-    this.eventHandlerMap = /* @__PURE__ */ new Map(), this.globalMessageHandler = (s, i) => {
-      if (M(s)) {
-        if (s.type === "event") {
-          const { eventName: a } = s, o = this.eventHandlerMap.get(a);
-          if (!o)
+class C {
+  constructor(t) {
+    this.eventHandlerMap = /* @__PURE__ */ new Map(), this.globalMessageHandler = (n, o) => {
+      if (T(n)) {
+        if (n.type === "event") {
+          const { eventName: i } = n, a = this.eventHandlerMap.get(i);
+          if (!a)
             return;
-          o.forEach((c) => {
+          a.forEach((c) => {
             try {
-              c(s.data, i.id);
-            } catch (h) {
-              console.error("[PubSubSubscriber] globalMessageHandler: failed to handle income message", h);
+              c(n.data, o.id);
+            } catch (p) {
+              console.error("[PubSubSubscriber] globalMessageHandler: failed to handle income message", p);
             }
           });
           return;
         }
-        console.error("[PubSubSubscriber] globalMessageHandler: unhandled message", s);
+        console.error("[PubSubSubscriber] globalMessageHandler: unhandled message", n);
       }
     };
-    const { brokerId: t, transport: n } = e;
-    this.brokerId = t, this.transport = n, this.transport.onMessage(this.globalMessageHandler);
+    const { brokerId: r, transport: s } = t;
+    this.brokerId = r, this.transport = s, this.transport.onMessage(this.globalMessageHandler);
   }
-  subscribe(e, t) {
-    const n = f(e);
-    let s = this.eventHandlerMap.get(n);
-    s || (s = /* @__PURE__ */ new Set(), this.eventHandlerMap.set(n, s)), s.add(t);
-    const i = b({
+  subscribe(t, r) {
+    const s = y(t);
+    let n = this.eventHandlerMap.get(s);
+    n || (n = /* @__PURE__ */ new Set(), this.eventHandlerMap.set(s, n)), n.add(r);
+    const o = m({
       type: "subscribe",
-      eventName: e
+      eventName: t
     });
-    this.transport.send(this.brokerId, i);
+    this.transport.send(this.brokerId, o);
   }
-  unsubscribe(e, t) {
-    const n = f(e);
-    let s = this.eventHandlerMap.get(n);
-    if (!s)
+  unsubscribe(t, r) {
+    const s = y(t);
+    let n = this.eventHandlerMap.get(s);
+    if (!n)
       return;
-    t ? s.delete(t) : this.eventHandlerMap.delete(n);
-    const i = b({
+    r ? n.delete(r) : this.eventHandlerMap.delete(s);
+    const o = m({
       type: "unsubscribe",
-      eventName: e
+      eventName: t
     });
-    this.transport.send(this.brokerId, i);
+    this.transport.send(this.brokerId, o);
   }
 }
-const w = !!Error.captureStackTrace, P = "APP_ERROR";
-class l extends Error {
-  constructor(e, t) {
-    super(e), this.name = new.target.name || P, this.cause = t, w && Error.captureStackTrace(this, this.constructor);
+const A = !!Error.captureStackTrace, D = "APP_ERROR";
+class E extends Error {
+  constructor(t, r) {
+    super(t), this.name = new.target.name || D, this.cause = r, A && Error.captureStackTrace(this, this.constructor);
   }
-  static getChainedMessage(e) {
-    let { message: t } = e;
-    return e instanceof l && e.cause && (t += `
-Caused by: ${l.getChainedMessage(e.cause)}`), t;
+  static getChainedMessage(t) {
+    let { message: r } = t;
+    return t instanceof E && t.cause && (r += `
+Caused by: ${E.getChainedMessage(t.cause)}`), r;
   }
   toJSON() {
     return {
       name: this.name,
       message: this.message,
-      cause: this.cause ? l.getChainedMessage(this.cause) : void 0
+      cause: this.cause ? E.getChainedMessage(this.cause) : void 0
     };
   }
 }
-const O = {
+const x = {
   INTERNAL_ERROR: "INTERNAL_ERROR"
-}, C = "RPC_ERROR";
-class D extends l {
-  constructor(e) {
-    super(e.message || "unknown rpc error"), this.name = C, this.code = (e == null ? void 0 : e.code) || O.INTERNAL_ERROR;
+}, G = "RPC_ERROR";
+class F extends E {
+  constructor(t) {
+    super(t.message || "unknown rpc error"), this.name = G, this.code = (t == null ? void 0 : t.code) || x.INTERNAL_ERROR;
   }
 }
-const A = (r) => !!r && typeof r == "object" && "protocol" in r && r.protocol === "iframe_rpc" && "version" in r && r.version === "1.0", H = ({ uniqId: r }) => (e) => ({
+const j = (e) => !!e && typeof e == "object" && "protocol" in e && e.protocol === "iframe_rpc" && "version" in e && e.version === "1.0", B = ({ uniqId: e }) => (t) => ({
   ...{
     protocol: "iframe_rpc",
     version: "1.0",
-    id: r(),
+    id: e(),
     timestamp: Date.now()
   },
-  ...e
-}), S = H({
-  uniqId: () => p()
+  ...t
+}), X = B({
+  uniqId: () => g()
 });
-class L {
-  constructor(e) {
-    this.pendingEntryMap = /* @__PURE__ */ new Map(), this.globalMessageHandler = (s) => {
-      if (A(s)) {
-        if (s.type === "response" && s.status === "ok") {
-          const i = s.id, a = this.pendingEntryMap.get(i);
-          if (!a) {
-            console.error("[RpcClient] globalMessageHandler: got success response without pending request", s);
+class U {
+  constructor(t) {
+    this.pendingEntryMap = /* @__PURE__ */ new Map(), this.globalMessageHandler = (n) => {
+      if (j(n)) {
+        if (n.type === "response" && n.status === "ok") {
+          const o = n.id, i = this.pendingEntryMap.get(o);
+          if (!i) {
+            console.error("[RpcClient] globalMessageHandler: got success response without pending request", n);
             return;
           }
-          this.pendingEntryMap.delete(i), a.resolve(s.result);
+          this.pendingEntryMap.delete(o), i.resolve(n.result);
           return;
         }
-        if (s.type === "response" && s.status === "error") {
-          const i = s.id, a = this.pendingEntryMap.get(i);
-          if (!a) {
-            console.error("[RpcClient] globalMessageHandler: got error response without pending request", s);
+        if (n.type === "response" && n.status === "error") {
+          const o = n.id, i = this.pendingEntryMap.get(o);
+          if (!i) {
+            console.error("[RpcClient] globalMessageHandler: got error response without pending request", n);
             return;
           }
-          this.pendingEntryMap.delete(i), a.reject(new D(s.error));
+          this.pendingEntryMap.delete(o), i.reject(new F(n.error));
           return;
         }
-        console.error("[RpcClient] globalMessageHandler: invalid message schema", s);
+        console.error("[RpcClient] globalMessageHandler: invalid message schema", n);
       }
     };
-    const { serverId: t, transport: n } = e;
-    this.serverId = t, this.transport = n, this.transport.onMessage(this.globalMessageHandler);
+    const { serverId: r, transport: s } = t;
+    this.serverId = r, this.transport = s, this.transport.onMessage(this.globalMessageHandler);
   }
-  makeRequest(e, t) {
-    const n = S({
+  makeRequest(t, r) {
+    const s = X({
       type: "request",
-      method: e,
-      params: t
-    }), s = new Promise((i, a) => {
-      this.pendingEntryMap.set(n.id, {
-        method: e,
-        resolve: (o) => {
-          i(o);
+      method: t,
+      params: r
+    }), n = new Promise((o, i) => {
+      this.pendingEntryMap.set(s.id, {
+        method: t,
+        resolve: (a) => {
+          o(a);
         },
-        reject: (o) => {
-          a(o);
+        reject: (a) => {
+          i(a);
         }
       });
     });
     try {
-      this.transport.send(this.serverId, n);
-    } catch (i) {
-      console.error("[RpcClient] makeRequest: failed to send rpc message", i);
-      const a = this.pendingEntryMap.get(n.id);
-      a && (this.pendingEntryMap.delete(n.id), a.reject(i));
+      this.transport.send(this.serverId, s);
+    } catch (o) {
+      console.error("[RpcClient] makeRequest: failed to send rpc message", o);
+      const i = this.pendingEntryMap.get(s.id);
+      i && (this.pendingEntryMap.delete(s.id), i.reject(o));
     }
-    return s;
+    return n;
   }
 }
-class k {
-  constructor(e) {
-    this.peers = /* @__PURE__ */ new Map(), this.onMessage = (n) => {
-      const s = (i) => {
-        const { data: a, origin: o, source: c } = i;
+class W {
+  constructor(t) {
+    this.peers = /* @__PURE__ */ new Map(), this.onMessage = (s) => {
+      const n = (o) => {
+        const { data: i, origin: a, source: c } = o;
         if (!c) {
           console.error("[PostMessageTransport] onMessage: source could not be empty");
           return;
         }
-        const h = this.findPeer(c, o);
-        if (h)
+        const p = this.findPeer(c, a);
+        if (p)
           try {
-            n(a, h);
-          } catch (g) {
-            console.error("[PostMessageTransport] onMessage: failed to call cb on message", g);
+            s(i, p);
+          } catch (b) {
+            console.error("[PostMessageTransport] onMessage: failed to call cb on message", b);
           }
       };
-      return this.localWindow.addEventListener("message", s), () => {
-        this.localWindow.removeEventListener("message", s);
+      return this.localWindow.addEventListener("message", n), () => {
+        this.localWindow.removeEventListener("message", n);
       };
     };
-    const { localWindow: t } = e;
-    this.localWindow = t || window;
+    const { localWindow: r } = t;
+    this.localWindow = r || window;
   }
-  send(e, t) {
-    const n = this.peers.get(e);
-    n && n.source.postMessage(t, n.origin);
+  send(t, r) {
+    const s = this.peers.get(t);
+    s && s.source.postMessage(r, s.origin);
   }
-  broadcast(e) {
-    this.peers.forEach((t) => {
-      t.source.postMessage(e, t.origin);
+  broadcast(t) {
+    this.peers.forEach((r) => {
+      r.source.postMessage(t, r.origin);
     });
   }
-  broadcastGroup(e, t) {
-    e.forEach((n) => {
-      this.send(n, t);
+  broadcastGroup(t, r) {
+    t.forEach((s) => {
+      this.send(s, r);
     });
   }
-  addPeer(e) {
-    this.peers.set(e.id, e);
+  addPeer(t) {
+    this.peers.set(t.id, t);
   }
-  removePeer(e) {
-    this.peers.delete(e);
+  removePeer(t) {
+    this.peers.delete(t);
   }
-  findPeer(e, t) {
-    for (const [n, s] of this.peers)
-      if (s.source === e && s.origin === t)
-        return s;
+  findPeer(t, r) {
+    for (const [s, n] of this.peers)
+      if (n.source === t && n.origin === r)
+        return n;
     return null;
   }
 }
-class G {
-  constructor(e) {
+const h = {
+  name: "UnknownError",
+  message: "Unknown error"
+}, M = (e, t = 3, r = 0) => {
+  if (e instanceof Error) {
+    const s = r < t && e.cause ? M(e.cause, t, r + 1) : void 0;
+    return {
+      name: e.name,
+      message: e.message,
+      stack: e.stack,
+      cause: s
+    };
+  }
+  if (typeof e == "string")
+    return {
+      name: h.name,
+      message: e
+    };
+  if (typeof e == "number" || typeof e == "bigint" || typeof e == "boolean")
+    return {
+      name: h.name,
+      message: String(e)
+    };
+  if (e && typeof e == "object")
+    try {
+      return {
+        name: h.name,
+        message: "message" in e && typeof e.message == "string" && e.message !== "" ? e.message : JSON.stringify(e)
+      };
+    } catch {
+      return {
+        name: h.name,
+        message: "Unserializable error object"
+      };
+    }
+  return h;
+}, $ = "get", I = (e, t) => {
+  var n;
+  let r, s;
+  return e instanceof Request ? (r = e.url, s = e.method) : e instanceof URL ? r = e.toString() : r = e, {
+    method: s || ((n = t == null ? void 0 : t.method) == null ? void 0 : n.toString()) || $,
+    url: r
+  };
+}, V = (e, t, r) => ({
+  statusCode: r.status,
+  ...I(e, t)
+}), z = (e) => {
+  const t = window.fetch;
+  Object.defineProperty(window, "fetch", {
+    value: async (s, n) => {
+      try {
+        const o = new Error("synthetic error"), i = await t(s, n), a = i.clone(), c = V(s, n, a);
+        if (i.status >= 500) {
+          const u = new Error("fetch response error");
+          u.stack = o.stack, e.report({
+            kind: "fetchResponseError",
+            type: "network",
+            data: c,
+            error: u
+          });
+        }
+        const {
+          arrayBuffer: p,
+          blob: b,
+          json: k,
+          text: N
+        } = i;
+        return i.json = async function() {
+          try {
+            return await k.call(this);
+          } catch (u) {
+            throw e.report({
+              type: "network",
+              kind: "fetchParseBodyError",
+              error: u,
+              data: {
+                parseType: "json",
+                ...c
+              }
+            }), u;
+          }
+        }, i.text = async function() {
+          try {
+            return await N.call(this);
+          } catch (u) {
+            throw e.report({
+              type: "network",
+              kind: "fetchParseBodyError",
+              error: u,
+              data: {
+                parseType: "text",
+                ...c
+              }
+            }), u;
+          }
+        }, i.blob = async function() {
+          try {
+            return await b.call(this);
+          } catch (u) {
+            throw e.report({
+              type: "network",
+              kind: "fetchParseBodyError",
+              error: u,
+              data: {
+                parseType: "blob",
+                ...c
+              }
+            }), u;
+          }
+        }, i.arrayBuffer = async function() {
+          try {
+            return await p.call(this);
+          } catch (u) {
+            throw e.report({
+              type: "network",
+              kind: "fetchParseBodyError",
+              error: u,
+              data: {
+                parseType: "arrayBuffer",
+                ...c
+              }
+            }), u;
+          }
+        }, i;
+      } catch (o) {
+        throw o instanceof Error && o.name === "AbortError" || e.report({
+          type: "network",
+          kind: "fetchRequestError",
+          error: o,
+          data: I(s, n)
+        }), o;
+      }
+    },
+    configurable: !1,
+    writable: !1
+  });
+}, K = (e) => {
+  window.addEventListener("unhandledrejection", ({ reason: t }) => {
+    e.report({
+      type: "runtime",
+      kind: "unhandledRejection",
+      error: t
+    });
+  }), window.addEventListener("error", ({ colno: t, error: r, filename: s, lineno: n, message: o }) => {
+    e.report({
+      type: "runtime",
+      kind: "uncaughtError",
+      error: r,
+      data: {
+        lineno: n,
+        colno: t,
+        message: o,
+        filename: s
+      }
+    });
+  });
+}, v = Symbol("patchedXHLHttpRequest"), d = Symbol("requestInfo"), J = (e) => ({
+  statusCode: e.status,
+  ...e[d]
+}), Z = (e) => (e[d] || (e[d] = {}), e[d]), Q = (e) => {
+  e[v] = !0;
+}, Y = (e) => e[v] === !0, ee = (e) => {
+  const t = XMLHttpRequest.prototype.send, r = XMLHttpRequest.prototype.open, s = function(...o) {
+    const [i, a] = o;
+    this[d] = {
+      method: i,
+      url: typeof a == "string" ? a : a.toString()
+    }, Y(this) || (Q(this), this.addEventListener("error", () => {
+      const c = new Error("XMLHttpRequest network error");
+      e.report({
+        type: "network",
+        kind: "xmlHttpRequestError",
+        data: this[d],
+        error: c
+      });
+    }), this.addEventListener("timeout", () => {
+      const c = new Error("XMLHttpRequest timeout error");
+      e.report({
+        type: "network",
+        kind: "xmlHttpRequestTimeoutError",
+        data: this[d],
+        error: c
+      });
+    }), this.addEventListener("load", () => {
+      if (this.status >= 500) {
+        const c = new Error("XMLHttpRequest response error");
+        e.report({
+          type: "network",
+          kind: "xmlHttpRequestLoadError",
+          data: J(this),
+          error: c
+        });
+      }
+    }));
+    try {
+      r.apply(this, o);
+    } catch (c) {
+      throw e.report({
+        type: "network",
+        kind: "xmlHttpRequestOpenError",
+        error: c,
+        data: this[d]
+      }), c;
+    }
+  }, n = function(o) {
+    try {
+      const i = Z(this), a = new Error("XMLHttpRequest request initiator");
+      i.requestStack = a.stack, t.call(this, o);
+    } catch (i) {
+      throw e.report({
+        type: "network",
+        kind: "xmlHttpRequestSendError",
+        error: i,
+        data: this[d]
+      }), i;
+    }
+  };
+  Object.defineProperty(XMLHttpRequest.prototype, "open", {
+    value: s,
+    configurable: !1,
+    writable: !1
+  }), Object.defineProperty(XMLHttpRequest.prototype, "send", {
+    value: n,
+    configurable: !1,
+    writable: !1
+  });
+};
+let R;
+class te {
+  constructor(t) {
+    this.onError = t;
+  }
+  report(t) {
+    const { error: r, ...s } = t;
+    this.onError({
+      ...s,
+      error: r ? M(r) : void 0
+    });
+  }
+  init() {
+    this.applyIntegrations();
+  }
+  applyIntegrations() {
+    R || (R = !0, K(this), ee(this), z(this));
+  }
+}
+class re {
+  constructor(t) {
     const {
-      serverId: t,
-      serverOrigin: n,
-      serverSource: s,
-      theme: i
-    } = e, a = {
-      id: t,
-      origin: n,
-      source: s
-    }, o = new k({});
-    o.addPeer(a), this.rpcClient = new L({
-      transport: o,
-      serverId: t
-    }), this.subscriber = new T({
-      transport: o,
-      brokerId: a.id
-    }), document.documentElement.dataset.theme = i;
+      serverId: r,
+      serverOrigin: s,
+      serverSource: n,
+      theme: o
+    } = t, i = {
+      id: r,
+      origin: s,
+      source: n
+    }, a = new W({});
+    a.addPeer(i), this.rpcClient = new U({
+      transport: a,
+      serverId: r
+    }), this.subscriber = new C({
+      transport: a,
+      brokerId: i.id
+    }), document.documentElement.dataset.theme = o, this.crashReporter = new te((c) => {
+      this.makeRequest("v1.system.report.crash", c);
+    });
   }
-  makeRequest(e, t) {
-    return this.rpcClient.makeRequest(e, t);
+  makeRequest(t, r) {
+    return this.rpcClient.makeRequest(t, r);
   }
-  subscribe(e, t) {
-    return this.subscriber.subscribe(e, t);
+  subscribe(t, r) {
+    return this.subscriber.subscribe(t, r);
   }
-  unsubscribe(e, t) {
-    return this.subscriber.unsubscribe(e, t);
+  unsubscribe(t, r) {
+    return this.subscriber.unsubscribe(t, r);
   }
   bootstrap() {
-    let e = { height: 0, width: 0 };
-    const t = () => {
-      const o = document.body;
+    let t = { height: 0, width: 0 };
+    const r = () => {
+      const a = document.body;
       return Math.max(
-        o.offsetHeight,
-        o.scrollHeight
+        a.offsetHeight,
+        a.scrollHeight
       );
-    }, n = () => {
-      const o = document.body;
+    }, s = () => {
+      const a = document.body;
       return Math.max(
-        o.offsetWidth,
-        o.scrollWidth
+        a.offsetWidth,
+        a.scrollWidth
       );
-    }, s = () => {
-      const o = n(), c = t();
-      (e.height !== c || e.width !== o) && (e = { height: c, width: o }, this.makeRequest("v1.system.resize.notify", { height: c, width: o }));
+    }, n = () => {
+      const a = s(), c = r();
+      (t.height !== c || t.width !== a) && (t = { height: c, width: a }, this.makeRequest("v1.system.resize.notify", { height: c, width: a }));
     };
-    s(), new ResizeObserver(s).observe(document.body), new MutationObserver(s).observe(document.body, {
+    n(), new ResizeObserver(n).observe(document.body), new MutationObserver(n).observe(document.body, {
       childList: !0,
       subtree: !0,
       attributes: !0,
       attributeFilter: ["style", "class", "hidden", "open"]
-    });
+    }), this.crashReporter.init();
   }
 }
-const x = () => {
-  const r = new URL(window.location.href), e = r.searchParams.get("origin") || "", t = r.searchParams.get("theme") || "dark", n = new G({
+const se = () => {
+  const e = new URL(window.location.href), t = e.searchParams.get("origin") || "", r = e.searchParams.get("theme") || "dark", s = new re({
     serverId: "server",
-    serverOrigin: e || window.parent.origin,
+    serverOrigin: t || window.parent.origin,
     serverSource: window.parent,
-    theme: t
+    theme: r
   });
-  return n.bootstrap(), n;
+  return s.bootstrap(), s;
 };
 export {
-  x as createExtHelper
+  se as createExtHelper
 };

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export declare const createExtHelper: () => ExtHelper;
 declare class ExtHelper {
     private rpcClient;
     private subscriber;
+    private crashReporter;
     constructor(props: TExtHelperProps);
     makeRequest<M extends Extract<keyof TApiContract['methods'], string>>(method: M, params: TApiContract['methods'][M]['params']): Promise<TV1Methods[M]["result"]>;
     subscribe<E extends Extract<keyof TApiContract['events'], string>>(eventName: E, handler: TAnyPubSubHandler<TApiContract['events'][E]>): void;
@@ -226,17 +227,12 @@ export declare type TV1ExtUser = {
     /** User username. */
     username: string;
     /** User activity ranking data when available. */
-    userRanking?: {
-        /** League representation of the user's activity level. Could be `grey`, `bronze`, `silver`, `gold`, `diamond`, `royal` or `legend`. */
-        league: TV1UserLeague;
-        /** Activity level from 1 to 100. */
-        level: number;
-    };
+    userRanking?: TV1UserRanking;
 };
 
 export declare type TV1Genders = 'male' | 'female' | 'group' | 'tranny';
 
-export declare type TV1Methods = TV1ExtMethods & TV1SystemMethods & TV1PaymentMethods & TV1ModelMethods & TV1ChatMethods & TV1PrivateMethods;
+export declare type TV1Methods = TV1ExtMethods & TV1SystemMethods & TV1PaymentMethods & TV1ModelMethods & TV1ChatMethods & TV1PrivateMethods & TV1MonitoringMethods;
 
 declare type TV1ModelEvents = {
     'v1.model.ext.settings.set.requested': null;
@@ -260,6 +256,23 @@ declare type TV1ModelMethods = {
 
 export declare type TV1ModelStatus = Exclude<(typeof V1_SHOW_STATUSES)[keyof typeof V1_SHOW_STATUSES], 'spy'>;
 
+declare type TV1MonitoringMethods = {
+    'v1.monitoring.report.error': {
+        params: {
+            data: unknown;
+            message: string;
+        };
+        result: null;
+    };
+    'v1.monitoring.report.log': {
+        params: {
+            data: unknown;
+            message: string;
+        };
+        result: null;
+    };
+};
+
 declare type TV1PaymentEvents = {
     'v1.payment.tokens.spend.succeeded': {
         isAnonymous: boolean;
@@ -285,7 +298,23 @@ declare type TV1PrivateMethods = {
     };
 };
 
+declare type TV1SerializedError = {
+    cause?: TV1SerializedError;
+    message: string;
+    name: string;
+    stack?: string;
+};
+
 declare type TV1SystemMethods = {
+    'v1.system.report.crash': {
+        params: {
+            data?: Record<string, unknown>;
+            error?: TV1SerializedError;
+            kind: string;
+            type: 'network' | 'runtime';
+        };
+        result: null;
+    };
     'v1.system.resize.notify': {
         params: {
             height: number;
@@ -309,6 +338,14 @@ export declare type TV1TokenSpendData = TUnknownDictionary;
  */
 declare type TV1UserLeague = 'grey' | 'bronze' | 'silver' | 'gold' | 'diamond' | 'royal' | 'legend';
 
+/** User activity ranking system */
+export declare type TV1UserRanking = {
+    /** League representation of the user's activity level. Could be `grey`, `bronze`, `silver`, `gold`, `diamond`, `royal` or `legend`. */
+    league: TV1UserLeague;
+    /** Activity level from 1 to 100. */
+    level: number;
+};
+
 export declare type TV1UserStatus = Exclude<(typeof V1_SHOW_STATUSES)[keyof typeof V1_SHOW_STATUSES], 'idle'>;
 
 export declare type TV1WhisperData = TUnknownDictionary;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stripchatdev/ext-helper",
   "private": false,
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "module": "./dist/ext-helper.js",
   "types": "./dist/index.d.ts",