Function wrap

packages/browser/src/helpers.ts:60–186

(
  fn: T | NonFunction,
  options: {
    mechanism?: Mechanism;
  } = {},
)

 * @hidden
 */
export function wrap<T extends WrappableFunction, NonFunction>(
  fn: T | NonFunction,
  options: {
    mechanism?: Mechanism;
  } = {},
): NonFunction | WrappedFunction<T> {
  // for future readers what this does is wrap a function and then create
  // a bi-directional wrapping between them.
  //
  // example: wrapped = wrap(original);
  //  original.__sentry_wrapped__ -> wrapped
  //  wrapped.__sentry_original__ -> original

  function isFunction(fn: T | NonFunction): fn is T {
    return typeof fn === 'function';
  }

  if (!isFunction(fn)) {
    return fn;
  }

  try {
    // If we're dealing with a function that was previously wrapped, return the original wrapper.
    // Check via hasOwnProperty so a `__sentry_wrapped__` inherited from a wrapped `Function.prototype`
    // is not mistaken for a real wrapper.
    const hasOwnWrapper = Object.prototype.hasOwnProperty.call(fn, '__sentry_wrapped__');
    if (hasOwnWrapper) {
      const wrapper = (fn as WrappedFunction<T>).__sentry_wrapped__;
      if (typeof wrapper === 'function') {
        return wrapper;
      } else {
        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means
        // that something messed with it. In that case we want to return the originally passed function.
        return fn;
      }
    }

    // We don't wanna wrap it twice
    if (getOriginalFunction(fn)) {
      return fn;
    }
  } catch {
    // Just accessing custom props in some Selenium environments
    // can cause a "Permission denied" exception (see raven-js#495).
    // Bail on wrapping and return the function as-is (defers to window.onerror).
    return fn;
  }

  // Wrap the function itself
  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`
  const sentryWrapped = function (this: unknown, ...args: unknown[]): unknown {
    // Track depth on GLOBAL_OBJ so the thirdPartyErrorFilterIntegration (in @sentry/core) can detect
    // that processEvent is running inside a sentryWrapped call, even with minified/bundled code.
    GLOBAL_OBJ._sentryWrappedDepth = (GLOBAL_OBJ._sentryWrappedDepth || 0) + 1;
    try {
      // Also wrap arguments that are themselves functions
      const wrappedArguments = args.map(arg => wrap(arg, options));