@bynder/compact-view 5.2.0 → 5.2.2

package/hub2.js

@@ -0,0 +1,442 @@
+import { DEFAULT_ENVIRONMENT as b } from "./constants6.js";
+import { DEBUG_BUILD as g } from "./debug-build4.js";
+import { Scope as d } from "./scope2.js";
+import { closeSession as x, makeSession as I, updateSession as v } from "./session2.js";
+import { SDK_VERSION as C } from "./version2.js";
+import { GLOBAL_OBJ as p, getGlobalSingleton as k } from "./worldwide2.js";
+import { isThenable as R } from "./is2.js";
+import { uuid4 as h } from "./misc2.js";
+import { consoleSandbox as N, logger as a } from "./logger3.js";
+import { dateTimestampInSeconds as y } from "./time2.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 R(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: y(), ...t }, S = i ? N(() => 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 V() {
+  const o = u();
+  if (o.__SENTRY__ && o.__SENTRY__.acs) {
+    const t = o.__SENTRY__.acs.getCurrentHub();
+    if (t)
+      return t;
+  }
+  return O(o);
+}
+function O(o = u()) {
+  return (!w(o) || // eslint-disable-next-line deprecation/deprecation
+  _(o).isOlderThan(E)) && m(o, new T()), _(o);
+}
+function w(o) {
+  return !!(o && o.__SENTRY__ && o.__SENTRY__.hub);
+}
+function _(o) {
+  return k("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,
+  V as getCurrentHub,
+  _ as getHubFromCarrier,
+  u as getMainCarrier,
+  f as makeMain,
+  m as setHubOnCarrier
+};