@bynder/compact-view 5.2.1 → 5.2.2

package/envelope.js

@@ -0,0 +1,113 @@
+import { dsnToString as d } from "./dsn.js";
+import { normalize as u } from "./normalize.js";
+import { dropUndefinedKeys as p } from "./object.js";
+function h(e, t = []) {
+  return [e, t];
+}
+function E(e, t) {
+  const [r, o] = e;
+  return [r, [...o, t]];
+}
+function S(e, t) {
+  const r = e[1];
+  for (const o of r) {
+    const n = o[0].type;
+    if (t(o, n))
+      return !0;
+  }
+  return !1;
+}
+function f(e, t) {
+  return (t || new TextEncoder()).encode(e);
+}
+function k(e, t) {
+  const [r, o] = e;
+  let n = JSON.stringify(r);
+  function i(s) {
+    typeof n == "string" ? n = typeof s == "string" ? n + s : [f(n, t), s] : n.push(typeof s == "string" ? f(s, t) : s);
+  }
+  for (const s of o) {
+    const [l, a] = s;
+    if (i(`
+${JSON.stringify(l)}
+`), typeof a == "string" || a instanceof Uint8Array)
+      i(a);
+    else {
+      let c;
+      try {
+        c = JSON.stringify(a);
+      } catch {
+        c = JSON.stringify(u(a));
+      }
+      i(c);
+    }
+  }
+  return typeof n == "string" ? n : y(n);
+}
+function y(e) {
+  const t = e.reduce((n, i) => n + i.length, 0), r = new Uint8Array(t);
+  let o = 0;
+  for (const n of e)
+    r.set(n, o), o += n.length;
+  return r;
+}
+function I(e, t) {
+  const r = typeof e.data == "string" ? f(e.data, t) : e.data;
+  return [
+    p({
+      type: "attachment",
+      length: r.length,
+      filename: e.filename,
+      content_type: e.contentType,
+      attachment_type: e.attachmentType
+    }),
+    r
+  ];
+}
+const m = {
+  session: "session",
+  sessions: "session",
+  attachment: "attachment",
+  transaction: "transaction",
+  event: "error",
+  client_report: "internal",
+  user_report: "default",
+  profile: "profile",
+  replay_event: "replay",
+  replay_recording: "replay",
+  check_in: "monitor",
+  feedback: "feedback",
+  span: "span",
+  statsd: "metric_bucket"
+};
+function A(e) {
+  return m[e];
+}
+function M(e) {
+  if (!e || !e.sdk)
+    return;
+  const { name: t, version: r } = e.sdk;
+  return { name: t, version: r };
+}
+function O(e, t, r, o) {
+  const n = e.sdkProcessingMetadata && e.sdkProcessingMetadata.dynamicSamplingContext;
+  return {
+    event_id: e.event_id,
+    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...t && { sdk: t },
+    ...!!r && o && { dsn: d(o) },
+    ...n && {
+      trace: p({ ...n })
+    }
+  };
+}
+export {
+  E as addItemToEnvelope,
+  I as createAttachmentEnvelopeItem,
+  h as createEnvelope,
+  O as createEventEnvelopeHeaders,
+  A as envelopeItemTypeToDataCategory,
+  S as forEachEnvelopeItem,
+  M as getSdkMetadataForEnvelopeHeader,
+  k as serializeEnvelope
+};

package/envelope2.js

@@ -0,0 +1,23 @@
+import { getSdkMetadataForEnvelopeHeader as p, createEventEnvelopeHeaders as c, createEnvelope as i } from "./envelope.js";
+import { dsnToString as d } from "./dsn.js";
+function k(e, s) {
+  return s && (e.sdk = e.sdk || {}, e.sdk.name = e.sdk.name || s.name, e.sdk.version = e.sdk.version || s.version, e.sdk.integrations = [...e.sdk.integrations || [], ...s.integrations || []], e.sdk.packages = [...e.sdk.packages || [], ...s.packages || []]), e;
+}
+function y(e, s, t, o) {
+  const n = p(t), r = {
+    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...n && { sdk: n },
+    ...!!o && s && { dsn: d(s) }
+  }, a = "aggregates" in e ? [{ type: "sessions" }, e] : [{ type: "session" }, e.toJSON()];
+  return i(r, [a]);
+}
+function E(e, s, t, o) {
+  const n = p(t), r = e.type && e.type !== "replay_event" ? e.type : "event";
+  k(e, t && t.sdk);
+  const a = c(e, n, o, s);
+  return delete e.sdkProcessingMetadata, i(a, [[{ type: r }, e]]);
+}
+export {
+  E as createEventEnvelope,
+  y as createSessionEnvelope
+};

package/envelope3.js

@@ -0,0 +1,24 @@
+import { serializeMetricBuckets as s } from "./utils4.js";
+import { dsnToString as c } from "./dsn.js";
+import { createEnvelope as m } from "./envelope.js";
+function a(r, e, t, o) {
+  const n = {
+    sent_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  t && t.sdk && (n.sdk = {
+    name: t.sdk.name,
+    version: t.sdk.version
+  }), o && e && (n.dsn = c(e));
+  const i = p(r);
+  return m(n, [i]);
+}
+function p(r) {
+  const e = s(r);
+  return [{
+    type: "statsd",
+    length: e.length
+  }, e];
+}
+export {
+  a as createMetricEnvelope
+};

package/error.js

@@ -0,0 +1,9 @@
+class o extends Error {
+  /** Display name of this error instance. */
+  constructor(t, r = "warn") {
+    super(t), this.message = t, this.name = new.target.prototype.constructor.name, Object.setPrototypeOf(this, new.target.prototype), this.logLevel = r;
+  }
+}
+export {
+  o as SentryError
+};

package/errors.js

@@ -0,0 +1,33 @@
+import { $ZodError as t, flattenError as a, formatError as s } from "./errors2.js";
+import { $constructor as u } from "./core.js";
+const d = (r, o) => {
+  t.init(r, o), r.name = "ZodError", Object.defineProperties(r, {
+    format: {
+      value: (e) => s(r, e)
+      // enumerable: false,
+    },
+    flatten: {
+      value: (e) => a(r, e)
+      // enumerable: false,
+    },
+    addIssue: {
+      value: (e) => r.issues.push(e)
+      // enumerable: false,
+    },
+    addIssues: {
+      value: (e) => r.issues.push(...e)
+      // enumerable: false,
+    },
+    isEmpty: {
+      get() {
+        return r.issues.length === 0;
+      }
+      // enumerable: false,
+    }
+  });
+}, E = u("ZodError", d, {
+  Parent: Error
+});
+export {
+  E as ZodRealError
+};

package/errors2.js

@@ -0,0 +1,55 @@
+import { $constructor as f } from "./core.js";
+import { jsonStringifyReplacer as p } from "./util.js";
+const c = (r, n) => {
+  r.name = "$ZodError", Object.defineProperty(r, "_zod", {
+    value: r._zod,
+    enumerable: !1
+  }), Object.defineProperty(r, "issues", {
+    value: n,
+    enumerable: !1
+  }), Object.defineProperty(r, "message", {
+    get() {
+      return JSON.stringify(n, p, 2);
+    },
+    enumerable: !0
+    // configurable: false,
+  }), Object.defineProperty(r, "toString", {
+    value: () => r.message,
+    enumerable: !1
+  });
+}, g = f("$ZodError", c), E = f("$ZodError", c, { Parent: Error });
+function _(r, n = (o) => o.message) {
+  const o = {}, i = [];
+  for (const s of r.issues)
+    s.path.length > 0 ? (o[s.path[0]] = o[s.path[0]] || [], o[s.path[0]].push(n(s))) : i.push(n(s));
+  return { formErrors: i, fieldErrors: o };
+}
+function b(r, n) {
+  const o = n || function(u) {
+    return u.message;
+  }, i = { _errors: [] }, s = (u) => {
+    for (const e of u.issues)
+      if (e.code === "invalid_union" && e.errors.length)
+        e.errors.map((t) => s({ issues: t }));
+      else if (e.code === "invalid_key")
+        s({ issues: e.issues });
+      else if (e.code === "invalid_element")
+        s({ issues: e.issues });
+      else if (e.path.length === 0)
+        i._errors.push(o(e));
+      else {
+        let t = i, a = 0;
+        for (; a < e.path.length; ) {
+          const l = e.path[a];
+          a === e.path.length - 1 ? (t[l] = t[l] || { _errors: [] }, t[l]._errors.push(o(e))) : t[l] = t[l] || { _errors: [] }, t = t[l], a++;
+        }
+      }
+  };
+  return s(r), i;
+}
+export {
+  g as $ZodError,
+  E as $ZodRealError,
+  _ as flattenError,
+  b as formatError
+};

package/es_ES.json.js

@@ -0,0 +1,18 @@
+const a = {
+  "colorpicker.opacity-input": "Opacidad",
+  "datepicker.clear-date": "Borrar fecha",
+  "datepicker.next-month": "Próximo mes",
+  "datepicker.open-calendar": "Abrir calendario",
+  "datepicker.previous-month": "Mes anterior",
+  "input.clear": "Borrar entrada",
+  "input.hide-password": "Ocultar contraseña",
+  "input.show-password": "Mostrar contraseña",
+  "modal.close": "Cerrar",
+  "multiselectchips.add-value": "Agregar ‘{value}’",
+  "multiselectchips.remove-all": "Quitar todos",
+  "pagination.next-page": "Siguiente página",
+  "pagination.previous-page": "Página anterior"
+};
+export {
+  a as default
+};

package/es_MX.json.js

@@ -0,0 +1,18 @@
+const a = {
+  "colorpicker.opacity-input": "Opacidad",
+  "datepicker.clear-date": "Borrar fecha",
+  "datepicker.next-month": "Próximo mes",
+  "datepicker.open-calendar": "Abrir calendario",
+  "datepicker.previous-month": "Mes anterior",
+  "input.clear": "Borrar entrada",
+  "input.hide-password": "Ocultar contraseña",
+  "input.show-password": "Mostrar contraseña",
+  "modal.close": "Cerrar",
+  "multiselectchips.add-value": "Agregar ‘{value}’",
+  "multiselectchips.remove-all": "Eliminar todo",
+  "pagination.next-page": "Siguiente página",
+  "pagination.previous-page": "Página anterior"
+};
+export {
+  a as default
+};

package/eventProcessors.js

@@ -0,0 +1,27 @@
+import { DEBUG_BUILD as m } from "./debug-build2.js";
+import { getGlobalSingleton as c } from "./worldwide.js";
+import { SyncPromise as p } from "./syncpromise.js";
+import { logger as g } from "./logger2.js";
+import { isThenable as a } from "./is.js";
+function d() {
+  return c("globalEventProcessors", () => []);
+}
+function G(o) {
+  d().push(o);
+}
+function f(o, r, e, l = 0) {
+  return new p((i, s) => {
+    const n = o[l];
+    if (r === null || typeof n != "function")
+      i(r);
+    else {
+      const t = n({ ...r }, e);
+      m && n.id && t === null && g.log(`Event processor "${n.id}" dropped event`), a(t) ? t.then((u) => f(o, u, e, l + 1).then(i)).then(null, s) : f(o, t, e, l + 1).then(i).then(null, s);
+    }
+  });
+}
+export {
+  G as addGlobalEventProcessor,
+  d as getGlobalEventProcessors,
+  f as notifyEventProcessors
+};

package/eventProcessors2.js

@@ -0,0 +1,23 @@
+import { DEBUG_BUILD as u } from "./debug-build4.js";
+import { getGlobalSingleton as p } from "./worldwide2.js";
+import { SyncPromise as c } from "./syncpromise2.js";
+import { logger as g } from "./logger3.js";
+import { isThenable as E } from "./is2.js";
+function v() {
+  return p("globalEventProcessors", () => []);
+}
+function s(t, r, e, l = 0) {
+  return new c((i, f) => {
+    const o = t[l];
+    if (r === null || typeof o != "function")
+      i(r);
+    else {
+      const n = o({ ...r }, e);
+      u && o.id && n === null && g.log(`Event processor "${o.id}" dropped event`), E(n) ? n.then((m) => s(t, m, e, l + 1).then(i)).then(null, f) : s(t, n, e, l + 1).then(i).then(null, f);
+    }
+  });
+}
+export {
+  v as getGlobalEventProcessors,
+  s as notifyEventProcessors
+};

package/eventbuilder.js

@@ -0,0 +1,128 @@
+import { addExceptionMechanism as u, addExceptionTypeValue as d } from "./misc.js";
+import { resolvedSyncPromise as g } from "./syncpromise.js";
+import { isErrorEvent as E, isDOMError as p, isDOMException as y, isError as _, isPlainObject as O, isEvent as m, isParameterizedString as M } from "./is.js";
+import { getClient as $ } from "./exports.js";
+import { normalizeToSize as b } from "./normalize.js";
+import { extractExceptionKeysForMessage as j } from "./object.js";
+function F(r, e) {
+  const o = l(r, e), t = {
+    type: e && e.name,
+    value: h(e)
+  };
+  return o.length && (t.stacktrace = { frames: o }), t.type === void 0 && t.value === "" && (t.value = "Unrecoverable error caught"), t;
+}
+function z(r, e, o, t) {
+  const i = $(), n = i && i.getOptions().normalizeDepth, s = {
+    exception: {
+      values: [
+        {
+          type: m(e) ? e.constructor.name : t ? "UnhandledRejection" : "Error",
+          value: N(e, { isUnhandledRejection: t })
+        }
+      ]
+    },
+    extra: {
+      __serialized__: b(e, n)
+    }
+  };
+  if (o) {
+    const a = l(r, o);
+    a.length && (s.exception.values[0].stacktrace = { frames: a });
+  }
+  return s;
+}
+function c(r, e) {
+  return {
+    exception: {
+      values: [F(r, e)]
+    }
+  };
+}
+function l(r, e) {
+  const o = e.stacktrace || e.stack || "", t = S(e);
+  try {
+    return r(o, t);
+  } catch {
+  }
+  return [];
+}
+const D = /Minified React error #\d+;/i;
+function S(r) {
+  if (r) {
+    if (typeof r.framesToPop == "number")
+      return r.framesToPop;
+    if (D.test(r.message))
+      return 1;
+  }
+  return 0;
+}
+function h(r) {
+  const e = r && r.message;
+  return e ? e.error && typeof e.error.message == "string" ? e.error.message : e : "No error message";
+}
+function I(r, e, o, t) {
+  const i = o && o.syntheticException || void 0, n = k(r, e, i, t);
+  return u(n), n.level = "error", o && o.event_id && (n.event_id = o.event_id), g(n);
+}
+function K(r, e, o = "info", t, i) {
+  const n = t && t.syntheticException || void 0, s = f(r, e, n, i);
+  return s.level = o, t && t.event_id && (s.event_id = t.event_id), g(s);
+}
+function k(r, e, o, t, i) {
+  let n;
+  if (E(e) && e.error)
+    return c(r, e.error);
+  if (p(e) || y(e)) {
+    const s = e;
+    if ("stack" in e)
+      n = c(r, e);
+    else {
+      const a = s.name || (p(s) ? "DOMError" : "DOMException"), v = s.message ? `${a}: ${s.message}` : a;
+      n = f(r, v, o, t), d(n, v);
+    }
+    return "code" in s && (n.tags = { ...n.tags, "DOMException.code": `${s.code}` }), n;
+  }
+  return _(e) ? c(r, e) : O(e) || m(e) ? (n = z(r, e, o, i), u(n, {
+    synthetic: !0
+  }), n) : (n = f(r, e, o, t), d(n, `${e}`), u(n, {
+    synthetic: !0
+  }), n);
+}
+function f(r, e, o, t) {
+  const i = {};
+  if (t && o) {
+    const n = l(r, o);
+    n.length && (i.exception = {
+      values: [{ value: e, stacktrace: { frames: n } }]
+    });
+  }
+  if (M(e)) {
+    const { __sentry_template_string__: n, __sentry_template_values__: s } = e;
+    return i.logentry = {
+      message: n,
+      params: s
+    }, i;
+  }
+  return i.message = e, i;
+}
+function N(r, { isUnhandledRejection: e }) {
+  const o = j(r), t = "exception";
+  return E(r) ? `Event \`ErrorEvent\` captured as ${t} with message \`${r.message}\`` : m(r) ? `Event \`${T(r)}\` (type=${r.type}) captured as ${t}` : `Object captured as ${t} with keys: ${o}`;
+}
+function T(r) {
+  try {
+    const e = Object.getPrototypeOf(r);
+    return e ? e.constructor.name : void 0;
+  } catch {
+  }
+}
+export {
+  c as eventFromError,
+  I as eventFromException,
+  K as eventFromMessage,
+  z as eventFromPlainObject,
+  f as eventFromString,
+  k as eventFromUnknownInput,
+  F as exceptionFromError,
+  l as parseStackFrames
+};

package/exports.js

@@ -0,0 +1,11 @@
+import { getCurrentHub as t } from "./hub.js";
+function r() {
+  return t().getClient();
+}
+function n() {
+  return t().getScope();
+}
+export {
+  r as getClient,
+  n as getCurrentScope
+};

package/exports2.js

@@ -0,0 +1,16 @@
+import { getCurrentHub as t } from "./hub2.js";
+import { parseEventHintOrCaptureContext as r } from "./prepareEvent2.js";
+function i(e, n) {
+  return t().captureException(e, r());
+}
+function p() {
+  return t().getClient();
+}
+function c() {
+  return t().getScope();
+}
+export {
+  i as captureException,
+  p as getClient,
+  c as getCurrentScope
+};

package/exports3.js

@@ -0,0 +1,8 @@
+import { getCurrentScope as r } from "./currentScopes.js";
+import { parseEventHintOrCaptureContext as e } from "./prepareEvent3.js";
+function i(t, n) {
+  return r().captureException(t, e());
+}
+export {
+  i as captureException
+};

package/fetch.js

@@ -0,0 +1,44 @@
+import { getNativeFetchImplementation as d, clearCachedFetchImplementation as h } from "./utils.js";
+import { createTransport as s } from "./base.js";
+import { rejectedSyncPromise as u } from "./syncpromise.js";
+function p(t, o = d()) {
+  let r = 0, n = 0;
+  function c(i) {
+    const a = i.body.length;
+    r += a, n++;
+    const m = {
+      body: i.body,
+      method: "POST",
+      referrerPolicy: "origin",
+      headers: t.headers,
+      // Outgoing requests are usually cancelled when navigating to a different page, causing a "TypeError: Failed to
+      // fetch" error and sending a "network_error" client-outcome - in Chrome, the request status shows "(cancelled)".
+      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're
+      // frequently sending events right before the user is switching pages (eg. whenfinishing navigation transactions).
+      // Gotchas:
+      // - `keepalive` isn't supported by Firefox
+      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch):
+      //   If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.
+      //   We will therefore only activate the flag when we're below that limit.
+      // There is also a limit of requests that can be open at the same time, so we also limit this to 15
+      // See https://github.com/getsentry/sentry-javascript/pull/7553 for details
+      keepalive: r <= 6e4 && n < 15,
+      ...t.fetchOptions
+    };
+    try {
+      return o(t.url, m).then((e) => (r -= a, n--, {
+        statusCode: e.status,
+        headers: {
+          "x-sentry-rate-limits": e.headers.get("X-Sentry-Rate-Limits"),
+          "retry-after": e.headers.get("Retry-After")
+        }
+      }));
+    } catch (e) {
+      return h(), r -= a, n--, u(e);
+    }
+  }
+  return s(t, c);
+}
+export {
+  p as makeFetchTransport
+};