@bynder/compact-view 5.2.0 → 5.2.2

package/base64Converter.js

@@ -12,4 +12,3 @@ export {
   c as convertAssetIdToBase64,
   s as convertOptionsToBase64
 };
-//# sourceMappingURL=base64Converter.js.map

package/baseclient.js

@@ -0,0 +1,498 @@
+import { getEnvelopeEndpointWithUrlEncodedAuth as D } from "./api.js";
+import { DEBUG_BUILD as l } from "./debug-build2.js";
+import { createEventEnvelope as M, createSessionEnvelope as A } from "./envelope2.js";
+import { getIsolationScope as O } from "./hub.js";
+import { setupIntegration as $, afterSetupIntegrations as P, setupIntegrations as B } from "./integration.js";
+import { createMetricEnvelope as T } from "./envelope3.js";
+import { updateSession as y } from "./session.js";
+import { getDynamicSamplingContextFromClient as N } from "./dynamicSamplingContext.js";
+import { prepareEvent as F } from "./prepareEvent.js";
+import { makeDsn as j } from "./dsn.js";
+import { logger as d } from "./logger2.js";
+import { checkOrSetAlreadyCaught as b } from "./misc.js";
+import { isPrimitive as z, isParameterizedString as R, isThenable as U, isPlainObject as w } from "./is.js";
+import { resolvedSyncPromise as L, SyncPromise as q, rejectedSyncPromise as G } from "./syncpromise.js";
+import { addItemToEnvelope as V, createAttachmentEnvelopeItem as W } from "./envelope.js";
+import { SentryError as u } from "./error.js";
+const x = "Not capturing exception because it's already been captured.";
+class lt {
+  /**
+   * A reference to a metrics aggregator
+   *
+   * @experimental Note this is alpha API. It may experience breaking changes in the future.
+   */
+  /** Options passed to the SDK. */
+  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */
+  /** Array of set up integrations. */
+  /** Indicates whether this client's integrations have been set up. */
+  /** Number of calls being processed */
+  /** Holds flushable  */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  /**
+   * Initializes this client instance.
+   *
+   * @param options Options for the client.
+   */
+  constructor(t) {
+    if (this._options = t, this._integrations = {}, this._integrationsInitialized = !1, this._numProcessing = 0, this._outcomes = {}, this._hooks = {}, this._eventProcessors = [], t.dsn ? this._dsn = j(t.dsn) : l && d.warn("No DSN provided, client will not send events."), this._dsn) {
+      const e = D(this._dsn, t);
+      this._transport = t.transport({
+        tunnel: this._options.tunnel,
+        recordDroppedEvent: this.recordDroppedEvent.bind(this),
+        ...t.transportOptions,
+        url: e
+      });
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  captureException(t, e, n) {
+    if (b(t)) {
+      l && d.log(x);
+      return;
+    }
+    let s = e && e.event_id;
+    return this._process(
+      this.eventFromException(t, e).then((r) => this._captureEvent(r, e, n)).then((r) => {
+        s = r;
+      })
+    ), s;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureMessage(t, e, n, s) {
+    let r = n && n.event_id;
+    const a = R(t) ? t : String(t), i = z(t) ? this.eventFromMessage(a, e, n) : this.eventFromException(t, n);
+    return this._process(
+      i.then((p) => this._captureEvent(p, n, s)).then((p) => {
+        r = p;
+      })
+    ), r;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureEvent(t, e, n) {
+    if (e && e.originalException && b(e.originalException)) {
+      l && d.log(x);
+      return;
+    }
+    let s = e && e.event_id;
+    const a = (t.sdkProcessingMetadata || {}).capturedSpanScope;
+    return this._process(
+      this._captureEvent(t, e, a || n).then((i) => {
+        s = i;
+      })
+    ), s;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureSession(t) {
+    typeof t.release != "string" ? l && d.warn("Discarded session because of missing or non-string release") : (this.sendSession(t), y(t, { init: !1 }));
+  }
+  /**
+   * @inheritDoc
+   */
+  getDsn() {
+    return this._dsn;
+  }
+  /**
+   * @inheritDoc
+   */
+  getOptions() {
+    return this._options;
+  }
+  /**
+   * @see SdkMetadata in @sentry/types
+   *
+   * @return The metadata of the SDK
+   */
+  getSdkMetadata() {
+    return this._options._metadata;
+  }
+  /**
+   * @inheritDoc
+   */
+  getTransport() {
+    return this._transport;
+  }
+  /**
+   * @inheritDoc
+   */
+  flush(t) {
+    const e = this._transport;
+    return e ? (this.metricsAggregator && this.metricsAggregator.flush(), this._isClientDoneProcessing(t).then((n) => e.flush(t).then((s) => n && s))) : L(!0);
+  }
+  /**
+   * @inheritDoc
+   */
+  close(t) {
+    return this.flush(t).then((e) => (this.getOptions().enabled = !1, this.metricsAggregator && this.metricsAggregator.close(), e));
+  }
+  /** Get all installed event processors. */
+  getEventProcessors() {
+    return this._eventProcessors;
+  }
+  /** @inheritDoc */
+  addEventProcessor(t) {
+    this._eventProcessors.push(t);
+  }
+  /**
+   * This is an internal function to setup all integrations that should run on the client.
+   * @deprecated Use `client.init()` instead.
+   */
+  setupIntegrations(t) {
+    (t && !this._integrationsInitialized || this._isEnabled() && !this._integrationsInitialized) && this._setupIntegrations();
+  }
+  /** @inheritdoc */
+  init() {
+    this._isEnabled() && this._setupIntegrations();
+  }
+  /**
+   * Gets an installed integration by its `id`.
+   *
+   * @returns The installed integration or `undefined` if no integration with that `id` was installed.
+   * @deprecated Use `getIntegrationByName()` instead.
+   */
+  getIntegrationById(t) {
+    return this.getIntegrationByName(t);
+  }
+  /**
+   * Gets an installed integration by its name.
+   *
+   * @returns The installed integration or `undefined` if no integration with that `name` was installed.
+   */
+  getIntegrationByName(t) {
+    return this._integrations[t];
+  }
+  /**
+   * Returns the client's instance of the given integration class, it any.
+   * @deprecated Use `getIntegrationByName()` instead.
+   */
+  getIntegration(t) {
+    try {
+      return this._integrations[t.id] || null;
+    } catch {
+      return l && d.warn(`Cannot retrieve integration ${t.id} from the current Client`), null;
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  addIntegration(t) {
+    const e = this._integrations[t.name];
+    $(this, t, this._integrations), e || P(this, [t]);
+  }
+  /**
+   * @inheritDoc
+   */
+  sendEvent(t, e = {}) {
+    this.emit("beforeSendEvent", t, e);
+    let n = M(t, this._dsn, this._options._metadata, this._options.tunnel);
+    for (const r of e.attachments || [])
+      n = V(
+        n,
+        W(
+          r,
+          this._options.transportOptions && this._options.transportOptions.textEncoder
+        )
+      );
+    const s = this._sendEnvelope(n);
+    s && s.then((r) => this.emit("afterSendEvent", t, r), null);
+  }
+  /**
+   * @inheritDoc
+   */
+  sendSession(t) {
+    const e = A(t, this._dsn, this._options._metadata, this._options.tunnel);
+    this._sendEnvelope(e);
+  }
+  /**
+   * @inheritDoc
+   */
+  recordDroppedEvent(t, e, n) {
+    if (this._options.sendClientReports) {
+      const s = typeof n == "number" ? n : 1, r = `${t}:${e}`;
+      l && d.log(`Recording outcome: "${r}"${s > 1 ? ` (${s} times)` : ""}`), this._outcomes[r] = (this._outcomes[r] || 0) + s;
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  captureAggregateMetrics(t) {
+    l && d.log(`Flushing aggregated metrics, number of metrics: ${t.length}`);
+    const e = T(
+      t,
+      this._dsn,
+      this._options._metadata,
+      this._options.tunnel
+    );
+    this._sendEnvelope(e);
+  }
+  // Keep on() & emit() signatures in sync with types' client.ts interface
+  /* eslint-disable @typescript-eslint/unified-signatures */
+  /** @inheritdoc */
+  /** @inheritdoc */
+  on(t, e) {
+    this._hooks[t] || (this._hooks[t] = []), this._hooks[t].push(e);
+  }
+  /** @inheritdoc */
+  /** @inheritdoc */
+  emit(t, ...e) {
+    this._hooks[t] && this._hooks[t].forEach((n) => n(...e));
+  }
+  /* eslint-enable @typescript-eslint/unified-signatures */
+  /** Setup integrations for this client. */
+  _setupIntegrations() {
+    const { integrations: t } = this._options;
+    this._integrations = B(this, t), P(this, t), this._integrationsInitialized = !0;
+  }
+  /** Updates existing session based on the provided event */
+  _updateSessionFromEvent(t, e) {
+    let n = !1, s = !1;
+    const r = e.exception && e.exception.values;
+    if (r) {
+      s = !0;
+      for (const p of r) {
+        const h = p.mechanism;
+        if (h && h.handled === !1) {
+          n = !0;
+          break;
+        }
+      }
+    }
+    const a = t.status === "ok";
+    (a && t.errors === 0 || a && n) && (y(t, {
+      ...n && { status: "crashed" },
+      errors: t.errors || Number(s || n)
+    }), this.captureSession(t));
+  }
+  /**
+   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying
+   * "no" (resolving to `false`) in order to give the client a chance to potentially finish first.
+   *
+   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not
+   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to
+   * `true`.
+   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and
+   * `false` otherwise
+   */
+  _isClientDoneProcessing(t) {
+    return new q((e) => {
+      let n = 0;
+      const s = 1, r = setInterval(() => {
+        this._numProcessing == 0 ? (clearInterval(r), e(!0)) : (n += s, t && n >= t && (clearInterval(r), e(!1)));
+      }, s);
+    });
+  }
+  /** Determines whether this SDK is enabled and a transport is present. */
+  _isEnabled() {
+    return this.getOptions().enabled !== !1 && this._transport !== void 0;
+  }
+  /**
+   * Adds common information to events.
+   *
+   * The information includes release and environment from `options`,
+   * breadcrumbs and context (extra, tags and user) from the scope.
+   *
+   * Information that is already present in the event is never overwritten. For
+   * nested objects, such as the context, keys are merged.
+   *
+   * @param event The original event.
+   * @param hint May contain additional information about the original exception.
+   * @param scope A scope containing event metadata.
+   * @returns A new event with more information.
+   */
+  _prepareEvent(t, e, n, s = O()) {
+    const r = this.getOptions(), a = Object.keys(this._integrations);
+    return !e.integrations && a.length > 0 && (e.integrations = a), this.emit("preprocessEvent", t, e), F(r, t, e, n, this, s).then((i) => {
+      if (i === null)
+        return i;
+      const p = {
+        ...s.getPropagationContext(),
+        ...n ? n.getPropagationContext() : void 0
+      };
+      if (!(i.contexts && i.contexts.trace) && p) {
+        const { traceId: g, spanId: S, parentSpanId: E, dsc: o } = p;
+        i.contexts = {
+          trace: {
+            trace_id: g,
+            span_id: S,
+            parent_span_id: E
+          },
+          ...i.contexts
+        };
+        const _ = o || N(g, this, n);
+        i.sdkProcessingMetadata = {
+          dynamicSamplingContext: _,
+          ...i.sdkProcessingMetadata
+        };
+      }
+      return i;
+    });
+  }
+  /**
+   * Processes the event and logs an error in case of rejection
+   * @param event
+   * @param hint
+   * @param scope
+   */
+  _captureEvent(t, e = {}, n) {
+    return this._processEvent(t, e, n).then(
+      (s) => s.event_id,
+      (s) => {
+        if (l) {
+          const r = s;
+          r.logLevel === "log" ? d.log(r.message) : d.warn(r);
+        }
+      }
+    );
+  }
+  /**
+   * Processes an event (either error or message) and sends it to Sentry.
+   *
+   * This also adds breadcrumbs and context information to the event. However,
+   * platform specific meta data (such as the User's IP address) must be added
+   * by the SDK implementor.
+   *
+   *
+   * @param event The event to send to Sentry.
+   * @param hint May contain additional information about the original exception.
+   * @param scope A scope containing event metadata.
+   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.
+   */
+  _processEvent(t, e, n) {
+    const s = this.getOptions(), { sampleRate: r } = s, a = C(t), i = k(t), p = t.type || "error", h = `before send for type \`${p}\``;
+    if (i && typeof r == "number" && Math.random() > r)
+      return this.recordDroppedEvent("sample_rate", "error", t), G(
+        new u(
+          `Discarding event because it's not included in the random sample (sampling rate = ${r})`,
+          "log"
+        )
+      );
+    const g = p === "replay_event" ? "replay" : p, E = (t.sdkProcessingMetadata || {}).capturedSpanIsolationScope;
+    return this._prepareEvent(t, e, n, E).then((o) => {
+      if (o === null)
+        throw this.recordDroppedEvent("event_processor", g, t), new u("An event processor returned `null`, will not send event.", "log");
+      if (e.data && e.data.__sentry__ === !0)
+        return o;
+      const f = H(s, o, e);
+      return Y(f, h);
+    }).then((o) => {
+      if (o === null) {
+        if (this.recordDroppedEvent("before_send", g, t), a) {
+          const v = 1 + (t.spans || []).length;
+          this.recordDroppedEvent("before_send", "span", v);
+        }
+        throw new u(`${h} returned \`null\`, will not send event.`, "log");
+      }
+      const _ = n && n.getSession();
+      if (!a && _ && this._updateSessionFromEvent(_, o), a) {
+        const m = o.sdkProcessingMetadata && o.sdkProcessingMetadata.spanCountBeforeProcessing || 0, v = o.spans ? o.spans.length : 0, I = m - v;
+        I > 0 && this.recordDroppedEvent("before_send", "span", I);
+      }
+      const f = o.transaction_info;
+      if (a && f && o.transaction !== t.transaction) {
+        const m = "custom";
+        o.transaction_info = {
+          ...f,
+          source: m
+        };
+      }
+      return this.sendEvent(o, e), o;
+    }).then(null, (o) => {
+      throw o instanceof u ? o : (this.captureException(o, {
+        data: {
+          __sentry__: !0
+        },
+        originalException: o
+      }), new u(
+        `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.
+Reason: ${o}`
+      ));
+    });
+  }
+  /**
+   * Occupies the client with processing and event
+   */
+  _process(t) {
+    this._numProcessing++, t.then(
+      (e) => (this._numProcessing--, e),
+      (e) => (this._numProcessing--, e)
+    );
+  }
+  /**
+   * @inheritdoc
+   */
+  _sendEnvelope(t) {
+    if (this.emit("beforeEnvelope", t), this._isEnabled() && this._transport)
+      return this._transport.send(t).then(null, (e) => {
+        l && d.error("Error while sending event:", e);
+      });
+    l && d.error("Transport disabled");
+  }
+  /**
+   * Clears outcomes on this client and returns them.
+   */
+  _clearOutcomes() {
+    const t = this._outcomes;
+    return this._outcomes = {}, Object.keys(t).map((e) => {
+      const [n, s] = e.split(":");
+      return {
+        reason: n,
+        category: s,
+        quantity: t[e]
+      };
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+}
+function Y(c, t) {
+  const e = `${t} must return \`null\` or a valid event.`;
+  if (U(c))
+    return c.then(
+      (n) => {
+        if (!w(n) && n !== null)
+          throw new u(e);
+        return n;
+      },
+      (n) => {
+        throw new u(`${t} rejected with ${n}`);
+      }
+    );
+  if (!w(c) && c !== null)
+    throw new u(e);
+  return c;
+}
+function H(c, t, e) {
+  const { beforeSend: n, beforeSendTransaction: s } = c;
+  if (k(t) && n)
+    return n(t, e);
+  if (C(t) && s) {
+    if (t.spans) {
+      const r = t.spans.length;
+      t.sdkProcessingMetadata = {
+        ...t.sdkProcessingMetadata,
+        spanCountBeforeProcessing: r
+      };
+    }
+    return s(t, e);
+  }
+  return t;
+}
+function k(c) {
+  return c.type === void 0;
+}
+function C(c) {
+  return c.type === "transaction";
+}
+export {
+  lt as BaseClient
+};

package/bind.js

@@ -0,0 +1,8 @@
+function u(n, r) {
+  return function() {
+    return n.apply(r, arguments);
+  };
+}
+export {
+  u as default
+};

package/browser.js

@@ -0,0 +1,44 @@
+import { isString as u } from "./is.js";
+import { getGlobalObject as m } from "./worldwide.js";
+const f = m(), p = 80;
+function L(c, n = {}) {
+  if (!c)
+    return "<unknown>";
+  try {
+    let t = c;
+    const s = 5, a = [];
+    let i = 0, o = 0;
+    const h = " > ", e = h.length;
+    let r;
+    const g = Array.isArray(n) ? n : n.keyAttrs, l = !Array.isArray(n) && n.maxStringLength || p;
+    for (; t && i++ < s && (r = A(t, g), !(r === "html" || i > 1 && o + a.length * e + r.length >= l)); )
+      a.push(r), o += r.length, t = t.parentNode;
+    return a.reverse().join(h);
+  } catch {
+    return "<unknown>";
+  }
+}
+function A(c, n) {
+  const t = c, s = [];
+  let a, i, o, h, e;
+  if (!t || !t.tagName)
+    return "";
+  if (f.HTMLElement && t instanceof HTMLElement && t.dataset && t.dataset.sentryComponent)
+    return t.dataset.sentryComponent;
+  s.push(t.tagName.toLowerCase());
+  const r = n && n.length ? n.filter((l) => t.getAttribute(l)).map((l) => [l, t.getAttribute(l)]) : null;
+  if (r && r.length)
+    r.forEach((l) => {
+      s.push(`[${l[0]}="${l[1]}"]`);
+    });
+  else if (t.id && s.push(`#${t.id}`), a = t.className, a && u(a))
+    for (i = a.split(/\s+/), e = 0; e < i.length; e++)
+      s.push(`.${i[e]}`);
+  const g = ["aria-label", "type", "name", "title", "alt"];
+  for (e = 0; e < g.length; e++)
+    o = g[e], h = t.getAttribute(o), h && s.push(`[${o}="${h}"]`);
+  return s.join("");
+}
+export {
+  L as htmlTreeAsString
+};

package/buildFullPath.js

@@ -0,0 +1,9 @@
+import r from "./isAbsoluteURL.js";
+import f from "./combineURLs.js";
+function u(l, i, t) {
+  let o = !r(i);
+  return l && (o || t == !1) ? f(l, i) : i;
+}
+export {
+  u as default
+};

package/buildURL.js

@@ -0,0 +1,23 @@
+import f from "./utils6.js";
+import d from "./AxiosURLSearchParams.js";
+function l(e) {
+  return encodeURIComponent(e).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+function m(e, c, i) {
+  if (!c)
+    return e;
+  const t = i && i.encode || l;
+  f.isFunction(i) && (i = {
+    serialize: i
+  });
+  const n = i && i.serialize;
+  let r;
+  if (n ? r = n(c, i) : r = f.isURLSearchParams(c) ? c.toString() : new d(c, i).toString(t), r) {
+    const a = e.indexOf("#");
+    a !== -1 && (e = e.slice(0, a)), e += (e.indexOf("?") === -1 ? "?" : "&") + r;
+  }
+  return e;
+}
+export {
+  m as default
+};

package/bundle.esm.js

@@ -0,0 +1,81 @@
+import { useRef as f, useState as O, useEffect as h, useCallback as b, useMemo as B } from "react";
+function k(e, t) {
+  var n = f(null), i = f(null);
+  i.current = t;
+  var r = f(null);
+  h(function() {
+    a();
+  });
+  var a = b(function() {
+    var u = r.current, d = i.current, c = u || (d ? d instanceof Element ? d : d.current : null);
+    n.current && n.current.element === c && n.current.subscriber === e || (n.current && n.current.cleanup && n.current.cleanup(), n.current = {
+      element: c,
+      subscriber: e,
+      // Only calling the subscriber, if there's an actual element to report.
+      // Setting cleanup to undefined unless a subscriber returns one, as an existing cleanup function would've been just called.
+      cleanup: c ? e(c) : void 0
+    });
+  }, [e]);
+  return h(function() {
+    return function() {
+      n.current && n.current.cleanup && (n.current.cleanup(), n.current = null);
+    };
+  }, []), b(function(u) {
+    r.current = u, a();
+  }, [a]);
+}
+function S(e, t, n) {
+  return e[t] ? e[t][0] ? e[t][0][n] : (
+    // TS complains about this, because the RO entry type follows the spec and does not reflect Firefox's current
+    // behaviour of returning objects instead of arrays for `borderBoxSize` and `contentBoxSize`.
+    // @ts-ignore
+    e[t][n]
+  ) : t === "contentBoxSize" ? e.contentRect[n === "inlineSize" ? "width" : "height"] : void 0;
+}
+function H(e) {
+  e === void 0 && (e = {});
+  var t = e.onResize, n = f(void 0);
+  n.current = t;
+  var i = e.round || Math.round, r = f(), a = O({
+    width: void 0,
+    height: void 0
+  }), u = a[0], d = a[1], c = f(!1);
+  h(function() {
+    return c.current = !1, function() {
+      c.current = !0;
+    };
+  }, []);
+  var o = f({
+    width: void 0,
+    height: void 0
+  }), s = k(b(function(x) {
+    return (!r.current || r.current.box !== e.box || r.current.round !== i) && (r.current = {
+      box: e.box,
+      round: i,
+      instance: new ResizeObserver(function(E) {
+        var R = E[0], z = e.box === "border-box" ? "borderBoxSize" : e.box === "device-pixel-content-box" ? "devicePixelContentBoxSize" : "contentBoxSize", m = S(R, z, "inlineSize"), g = S(R, z, "blockSize"), l = m ? i(m) : void 0, v = g ? i(g) : void 0;
+        if (o.current.width !== l || o.current.height !== v) {
+          var w = {
+            width: l,
+            height: v
+          };
+          o.current.width = l, o.current.height = v, n.current ? n.current(w) : c.current || d(w);
+        }
+      })
+    }), r.current.instance.observe(x, {
+      box: e.box
+    }), function() {
+      r.current && r.current.instance.unobserve(x);
+    };
+  }, [e.box, i]), e.ref);
+  return B(function() {
+    return {
+      ref: s,
+      width: u.width,
+      height: u.height
+    };
+  }, [s, u.width, u.height]);
+}
+export {
+  H as default
+};

package/calculateContainerMaxHeight.js

@@ -0,0 +1,12 @@
+function f(n, t, i = {}) {
+  if (!n || !t)
+    return;
+  const {
+    triggerOffset: o = 0,
+    containerOffset: e = 0
+  } = i, c = window.innerHeight - t.bottom - o - e, a = t.top - o - e;
+  return Math.max(a, c);
+}
+export {
+  f as calculateContainerMaxHeight
+};