use type overload

Author: mydea

packages/browser/src/helpers.ts

@@ -31,6 +31,21 @@ export function ignoreNextOnError(): void {
   });
 }
 
+// eslint-disable-next-line @typescript-eslint/ban-types
+type WrappableFunction = Function;
+
+export function wrap<T extends WrappableFunction>(
+  fn: T,
+  options?: {
+    mechanism?: Mechanism;
+  },
+): WrappedFunction<T>;
+export function wrap<NonFunction>(
+  fn: NonFunction,
+  options?: {
+    mechanism?: Mechanism;
+  },
+): NonFunction;
 /**
  * Instruments the given function and sends an event to Sentry every time the
  * function throws an exception.
@@ -40,21 +55,20 @@ export function ignoreNextOnError(): void {
  * @returns The wrapped function.
  * @hidden
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function wrap<T extends Function, NonFunctionType>(
-  fn: T | NonFunctionType,
+export function wrap<T extends WrappableFunction, NonFunction>(
+  fn: T | NonFunction,
   options: {
     mechanism?: Mechanism;
   } = {},
-): NonFunctionType | WrappedFunction<T> {
+): 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 | NonFunctionType): fn is T {
+  function isFunction(fn: T | NonFunction): fn is T {
     return typeof fn === 'function';
   }
 

packages/browser/test/helpers.test.ts

@@ -19,6 +19,18 @@ describe('internal wrap()', () => {
     expect(wrap(num)).toBe(num);
   });
 
+  it('correctly infers types', () => {
+    const a = wrap(42);
+    expect(a > 40).toBe(true);
+
+    const b = wrap('42');
+    expect(b.length).toBe(2);
+
+    const c = wrap(() => 42);
+    expect(c()).toBe(42);
+    expect(c.__sentry_original__).toBeInstanceOf(Function);
+  });
+
   it('should preserve correct function name when accessed', () => {
     const namedFunction = (): number => 1337;
     expect(wrap(namedFunction)).not.toBe(namedFunction);
@@ -149,7 +161,7 @@ describe('internal wrap()', () => {
   });
 
   it('internal flags shouldnt be enumerable', () => {
-    const fn = (() => 1337) as WrappedFunction;
+    const fn = () => 1337;
     const wrapped = wrap(fn);
 
     // Shouldn't show up in iteration
@@ -159,7 +171,7 @@ describe('internal wrap()', () => {
     expect(Object.keys(wrapped)).toEqual(expect.not.arrayContaining(['__sentry_wrapped__']));
     // But should be accessible directly
     expect(wrapped.__sentry_original__).toBe(fn);
-    expect(fn.__sentry_wrapped__).toBe(wrapped);
+    expect((fn as WrappedFunction).__sentry_wrapped__).toBe(wrapped);
   });
 
   it('should only return __sentry_wrapped__ when it is a function', () => {