@bynder/compact-view 5.2.0 → 5.2.2

package/handlers.js

@@ -1,7 +1,92 @@
-const t = {
-  autocomplete: "/api/v4/filters/autocompleteMetaPropertyOptions"
-};
-export {
-  t as handlers
-};
-//# sourceMappingURL=handlers.js.map
+import "./index32.js";
+import { http as t } from "./http.js";
+import { HttpResponse as a } from "./HttpResponse.js";
+const e = [
+  {
+    id: "7ad5864b-814d-4505-989f-cab02354d9b6",
+    metadata: {},
+    name: "UcCO3FwrK3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuLyfMZhrib2Bg-4.ttf",
+    path: "https://static-fonts-development.bynder.io/UcCO3FwrK3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuLyfMZhrib2Bg-4.ttf",
+    size: 309828,
+    type: "ttf",
+    version: "Version 3.019;git-0a5106e0b"
+  },
+  {
+    id: "43aaa9b7-749f-4e2a-8bd8-b6f235848a99",
+    metadata: {},
+    name: "UcCO3FwrK3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuLyfAZ9hjp-Ek-_0ew.woff",
+    path: "https://static-fonts-development.bynder.io/UcCO3FwrK3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuLyfAZ9hjp-Ek-_0ew.woff",
+    size: 22132,
+    type: "woff",
+    version: "Version 3.019;git-0a5106e0b"
+  },
+  {
+    id: "acae6a75-25bc-4628-a146-70574bce3cf0",
+    metadata: {},
+    name: "UcCO3FwrK3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuLyfAZ9hiJ-Ek-_EeA.woff2",
+    path: "https://static-fonts-development.bynder.io/UcCO3FwrK3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuLyfAZ9hiJ-Ek-_EeA.woff2",
+    size: 16828,
+    type: "woff2",
+    version: "Version 3.019;git-0a5106e0b"
+  }
+];
+t.get("/v7/fonts/v2/default/", () => a.json({
+  family: {
+    id: "b7c14751-2bca-44d7-ba9d-4befc890592b",
+    name: "Inter",
+    portal_id: null,
+    subfamilies: [
+      {
+        id: "9aa51511-710b-4aea-a289-e31b47472c24",
+        font_id: "b7c14751-2bca-44d7-ba9d-4befc890592b",
+        name: "Thin",
+        full_name: "Inter Thin",
+        postscript_name: "Inter-Thin",
+        is_italic: !1,
+        weight: "250",
+        files: e
+      },
+      {
+        id: "15145e11-07d7-4371-a86a-6774fe2505b1",
+        font_id: "b7c14751-2bca-44d7-ba9d-4befc890592b",
+        name: "ExtraLight",
+        full_name: "Inter ExtraLight",
+        postscript_name: "Inter-ExtraLight",
+        is_italic: !1,
+        weight: "250",
+        files: e
+      },
+      {
+        id: "7469f541-b180-4483-91f5-e503b4b583da",
+        font_id: "b7c14751-2bca-44d7-ba9d-4befc890592b",
+        name: "Light",
+        full_name: "Inter Light",
+        postscript_name: "Inter-Light",
+        is_italic: !1,
+        weight: "300",
+        files: e
+      },
+      {
+        id: "49d01d7d-6e3d-4b9e-8110-03268a48d2e1",
+        font_id: "b7c14751-2bca-44d7-ba9d-4befc890592b",
+        name: "Regular",
+        full_name: "Inter Regular",
+        postscript_name: "Inter-Regular",
+        is_italic: !1,
+        weight: "400",
+        files: e
+      },
+      {
+        id: "d730253d-667f-46e3-8982-1f3a0de15fe7",
+        font_id: "b7c14751-2bca-44d7-ba9d-4befc890592b",
+        name: "Medium",
+        full_name: "Inter Medium",
+        postscript_name: "Inter-Medium",
+        is_italic: !1,
+        weight: "500",
+        files: e
+      }
+    ]
+  },
+  default_subfamily: "49d01d7d-6e3d-4b9e-8110-03268a48d2e1"
+}));

package/handlers2.js

@@ -0,0 +1,6 @@
+const t = {
+  autocomplete: "/api/v4/filters/autocompleteMetaPropertyOptions"
+};
+export {
+  t as handlers
+};

package/helpers.js

@@ -1,7 +1,5 @@
-function n(e, t) {
-  t && e.key === "Enter" && (e.preventDefault(), t(e));
-}
+import { GLOBAL_OBJ as o } from "./worldwide.js";
+const t = o;
 export {
-  n as handleEnter
+  t as WINDOW
 };
-//# sourceMappingURL=helpers.js.map

package/helpers2.js

@@ -0,0 +1,6 @@
+function n(e, t) {
+  t && e.key === "Enter" && (e.preventDefault(), t(e));
+}
+export {
+  n as handleEnter
+};

package/hexFromPercentage.js

@@ -0,0 +1,7 @@
+function o(t) {
+  const e = Math.round(parseInt(t, 10) * 255 / 100).toString(16).toUpperCase();
+  return e.length < 2 ? `0${e}` : e;
+}
+export {
+  o as hexFromPercentage
+};

package/http.js

@@ -0,0 +1,17 @@
+import { HttpMethods as e, HttpHandler as H } from "./HttpHandler.js";
+function t(p) {
+  return (r, n, o = {}) => new H(p, r, n, o);
+}
+const T = {
+  all: t(/.+/),
+  head: t(e.HEAD),
+  get: t(e.GET),
+  post: t(e.POST),
+  put: t(e.PUT),
+  delete: t(e.DELETE),
+  patch: t(e.PATCH),
+  options: t(e.OPTIONS)
+};
+export {
+  T as http
+};

package/hub.js

@@ -0,0 +1,446 @@
+import { DEFAULT_ENVIRONMENT as b } from "./constants.js";
+import { DEBUG_BUILD as g } from "./debug-build2.js";
+import { Scope as d } from "./scope.js";
+import { closeSession as x, makeSession as I, updateSession as v } from "./session.js";
+import { SDK_VERSION as C } from "./version.js";
+import { isThenable as k } from "./is.js";
+import { uuid4 as h } from "./misc.js";
+import { consoleSandbox as R, logger as a } from "./logger2.js";
+import { dateTimestampInSeconds as N } from "./time.js";
+import { GLOBAL_OBJ as p, getGlobalSingleton as y } from "./worldwide.js";
+const E = parseFloat(C), B = 100;
+class T {
+  /** Is a {@link Layer}[] containing the client and scope */
+  /** Contains the last event id of a captured event.  */
+  /**
+   * Creates a new instance of the hub, will push one {@link Layer} into the
+   * internal stack on creation.
+   *
+   * @param client bound to the hub.
+   * @param scope bound to the hub.
+   * @param version number, higher number means higher priority.
+   *
+   * @deprecated Instantiation of Hub objects is deprecated and the constructor will be removed in version 8 of the SDK.
+   *
+   * If you are currently using the Hub for multi-client use like so:
+   *
+   * ```
+   * // OLD
+   * const hub = new Hub();
+   * hub.bindClient(client);
+   * makeMain(hub)
+   * ```
+   *
+   * instead initialize the client as follows:
+   *
+   * ```
+   * // NEW
+   * Sentry.withIsolationScope(() => {
+   *    Sentry.setCurrentClient(client);
+   *    client.init();
+   * });
+   * ```
+   *
+   * If you are using the Hub to capture events like so:
+   *
+   * ```
+   * // OLD
+   * const client = new Client();
+   * const hub = new Hub(client);
+   * hub.captureException()
+   * ```
+   *
+   * instead capture isolated events as follows:
+   *
+   * ```
+   * // NEW
+   * const client = new Client();
+   * const scope = new Scope();
+   * scope.setClient(client);
+   * scope.captureException();
+   * ```
+   */
+  constructor(t, e, s, n = E) {
+    this._version = n;
+    let i;
+    e ? i = e : (i = new d(), i.setClient(t));
+    let r;
+    s ? r = s : (r = new d(), r.setClient(t)), this._stack = [{ scope: i }], t && this.bindClient(t), this._isolationScope = r;
+  }
+  /**
+   * Checks if this hub's version is older than the given version.
+   *
+   * @param version A version number to compare to.
+   * @return True if the given version is newer; otherwise false.
+   *
+   * @deprecated This will be removed in v8.
+   */
+  isOlderThan(t) {
+    return this._version < t;
+  }
+  /**
+   * This binds the given client to the current scope.
+   * @param client An SDK client (client) instance.
+   *
+   * @deprecated Use `initAndBind()` directly, or `setCurrentClient()` and/or `client.init()` instead.
+   */
+  bindClient(t) {
+    const e = this.getStackTop();
+    e.client = t, e.scope.setClient(t), t && t.setupIntegrations && t.setupIntegrations();
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use `withScope` instead.
+   */
+  pushScope() {
+    const t = this.getScope().clone();
+    return this.getStack().push({
+      // eslint-disable-next-line deprecation/deprecation
+      client: this.getClient(),
+      scope: t
+    }), t;
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use `withScope` instead.
+   */
+  popScope() {
+    return this.getStack().length <= 1 ? !1 : !!this.getStack().pop();
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use `Sentry.withScope()` instead.
+   */
+  withScope(t) {
+    const e = this.pushScope();
+    let s;
+    try {
+      s = t(e);
+    } catch (n) {
+      throw this.popScope(), n;
+    }
+    return k(s) ? s.then(
+      (n) => (this.popScope(), n),
+      (n) => {
+        throw this.popScope(), n;
+      }
+    ) : (this.popScope(), s);
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use `Sentry.getClient()` instead.
+   */
+  getClient() {
+    return this.getStackTop().client;
+  }
+  /**
+   * Returns the scope of the top stack.
+   *
+   * @deprecated Use `Sentry.getCurrentScope()` instead.
+   */
+  getScope() {
+    return this.getStackTop().scope;
+  }
+  /**
+   * @deprecated Use `Sentry.getIsolationScope()` instead.
+   */
+  getIsolationScope() {
+    return this._isolationScope;
+  }
+  /**
+   * Returns the scope stack for domains or the process.
+   * @deprecated This will be removed in v8.
+   */
+  getStack() {
+    return this._stack;
+  }
+  /**
+   * Returns the topmost scope layer in the order domain > local > process.
+   * @deprecated This will be removed in v8.
+   */
+  getStackTop() {
+    return this._stack[this._stack.length - 1];
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use `Sentry.captureException()` instead.
+   */
+  captureException(t, e) {
+    const s = this._lastEventId = e && e.event_id ? e.event_id : h(), n = new Error("Sentry syntheticException");
+    return this.getScope().captureException(t, {
+      originalException: t,
+      syntheticException: n,
+      ...e,
+      event_id: s
+    }), s;
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use  `Sentry.captureMessage()` instead.
+   */
+  captureMessage(t, e, s) {
+    const n = this._lastEventId = s && s.event_id ? s.event_id : h(), i = new Error(t);
+    return this.getScope().captureMessage(t, e, {
+      originalException: t,
+      syntheticException: i,
+      ...s,
+      event_id: n
+    }), n;
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use `Sentry.captureEvent()` instead.
+   */
+  captureEvent(t, e) {
+    const s = e && e.event_id ? e.event_id : h();
+    return t.type || (this._lastEventId = s), this.getScope().captureEvent(t, { ...e, event_id: s }), s;
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated This will be removed in v8.
+   */
+  lastEventId() {
+    return this._lastEventId;
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use `Sentry.addBreadcrumb()` instead.
+   */
+  addBreadcrumb(t, e) {
+    const { scope: s, client: n } = this.getStackTop();
+    if (!n) return;
+    const { beforeBreadcrumb: i = null, maxBreadcrumbs: r = B } = n.getOptions && n.getOptions() || {};
+    if (r <= 0) return;
+    const c = { timestamp: N(), ...t }, S = i ? R(() => i(c, e)) : c;
+    S !== null && (n.emit && n.emit("beforeAddBreadcrumb", S, e), s.addBreadcrumb(S, r));
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use `Sentry.setUser()` instead.
+   */
+  setUser(t) {
+    this.getScope().setUser(t), this.getIsolationScope().setUser(t);
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use `Sentry.setTags()` instead.
+   */
+  setTags(t) {
+    this.getScope().setTags(t), this.getIsolationScope().setTags(t);
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use `Sentry.setExtras()` instead.
+   */
+  setExtras(t) {
+    this.getScope().setExtras(t), this.getIsolationScope().setExtras(t);
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use `Sentry.setTag()` instead.
+   */
+  setTag(t, e) {
+    this.getScope().setTag(t, e), this.getIsolationScope().setTag(t, e);
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use `Sentry.setExtra()` instead.
+   */
+  setExtra(t, e) {
+    this.getScope().setExtra(t, e), this.getIsolationScope().setExtra(t, e);
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use `Sentry.setContext()` instead.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setContext(t, e) {
+    this.getScope().setContext(t, e), this.getIsolationScope().setContext(t, e);
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use `getScope()` directly.
+   */
+  configureScope(t) {
+    const { scope: e, client: s } = this.getStackTop();
+    s && t(e);
+  }
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line deprecation/deprecation
+  run(t) {
+    const e = f(this);
+    try {
+      t(this);
+    } finally {
+      f(e);
+    }
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use `Sentry.getClient().getIntegrationByName()` instead.
+   */
+  getIntegration(t) {
+    const e = this.getClient();
+    if (!e) return null;
+    try {
+      return e.getIntegration(t);
+    } catch {
+      return g && a.warn(`Cannot retrieve integration ${t.id} from the current Hub`), null;
+    }
+  }
+  /**
+   * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.
+   *
+   * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a
+   * new child span within the transaction or any span, call the respective `.startChild()` method.
+   *
+   * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.
+   *
+   * The transaction must be finished with a call to its `.end()` method, at which point the transaction with all its
+   * finished child spans will be sent to Sentry.
+   *
+   * @param context Properties of the new `Transaction`.
+   * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent
+   * default values). See {@link Options.tracesSampler}.
+   *
+   * @returns The transaction which was just started
+   *
+   * @deprecated Use `startSpan()`, `startSpanManual()` or `startInactiveSpan()` instead.
+   */
+  startTransaction(t, e) {
+    const s = this._callExtensionMethod("startTransaction", t, e);
+    return g && !s && (this.getClient() ? a.warn(`Tracing extension 'startTransaction' has not been added. Call 'addTracingExtensions' before calling 'init':
+Sentry.addTracingExtensions();
+Sentry.init({...});
+`) : a.warn(
+      "Tracing extension 'startTransaction' is missing. You should 'init' the SDK before calling 'startTransaction'"
+    )), s;
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use `spanToTraceHeader()` instead.
+   */
+  traceHeaders() {
+    return this._callExtensionMethod("traceHeaders");
+  }
+  /**
+   * @inheritDoc
+   *
+   * @deprecated Use top level `captureSession` instead.
+   */
+  captureSession(t = !1) {
+    if (t)
+      return this.endSession();
+    this._sendSessionUpdate();
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use top level `endSession` instead.
+   */
+  endSession() {
+    const e = this.getStackTop().scope, s = e.getSession();
+    s && x(s), this._sendSessionUpdate(), e.setSession();
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use top level `startSession` instead.
+   */
+  startSession(t) {
+    const { scope: e, client: s } = this.getStackTop(), { release: n, environment: i = b } = s && s.getOptions() || {}, { userAgent: r } = p.navigator || {}, l = I({
+      release: n,
+      environment: i,
+      user: e.getUser(),
+      ...r && { userAgent: r },
+      ...t
+    }), c = e.getSession && e.getSession();
+    return c && c.status === "ok" && v(c, { status: "exited" }), this.endSession(), e.setSession(l), l;
+  }
+  /**
+   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests
+   * when Tracing is used.
+   *
+   * @deprecated Use top-level `getClient().getOptions().sendDefaultPii` instead. This function
+   * only unnecessarily increased API surface but only wrapped accessing the option.
+   */
+  shouldSendDefaultPii() {
+    const t = this.getClient(), e = t && t.getOptions();
+    return !!(e && e.sendDefaultPii);
+  }
+  /**
+   * Sends the current Session on the scope
+   */
+  _sendSessionUpdate() {
+    const { scope: t, client: e } = this.getStackTop(), s = t.getSession();
+    s && e && e.captureSession && e.captureSession(s);
+  }
+  /**
+   * Calls global extension method and binding current instance to the function call
+   */
+  // @ts-expect-error Function lacks ending return statement and return type does not include 'undefined'. ts(2366)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _callExtensionMethod(t, ...e) {
+    const n = u().__SENTRY__;
+    if (n && n.extensions && typeof n.extensions[t] == "function")
+      return n.extensions[t].apply(this, e);
+    g && a.warn(`Extension method ${t} couldn't be found, doing nothing.`);
+  }
+}
+function u() {
+  return p.__SENTRY__ = p.__SENTRY__ || {
+    extensions: {},
+    hub: void 0
+  }, p;
+}
+function f(o) {
+  const t = u(), e = _(t);
+  return m(t, o), e;
+}
+function O() {
+  const o = u();
+  if (o.__SENTRY__ && o.__SENTRY__.acs) {
+    const t = o.__SENTRY__.acs.getCurrentHub();
+    if (t)
+      return t;
+  }
+  return w(o);
+}
+function K() {
+  return O().getIsolationScope();
+}
+function w(o = u()) {
+  return (!H(o) || // eslint-disable-next-line deprecation/deprecation
+  _(o).isOlderThan(E)) && m(o, new T()), _(o);
+}
+function H(o) {
+  return !!(o && o.__SENTRY__ && o.__SENTRY__.hub);
+}
+function _(o) {
+  return y("hub", () => new T(), o);
+}
+function m(o, t) {
+  if (!o) return !1;
+  const e = o.__SENTRY__ = o.__SENTRY__ || {};
+  return e.hub = t, !0;
+}
+export {
+  E as API_VERSION,
+  T as Hub,
+  O as getCurrentHub,
+  _ as getHubFromCarrier,
+  K as getIsolationScope,
+  u as getMainCarrier,
+  f as makeMain,
+  m as setHubOnCarrier
+};