[Web] Remove invokeNullableMethod (#4084)

## Description

This PR removes `invokeNullableMethod` function from `web`.

From what I've found, this function is no longer necessary and makes web
codebase less readable.

On web we only deal with functions. The only exception would be an
`Animated.event`, but this can be an object iff `useNativeDriver` is set
to `true`. However, [this is not supported on
`web`](https://necolas.github.io/react-native-web/docs/react-native-compatibility/?utm_source=openai).
Also, part of the function refers to the old Reanimated 1 API, which is
no longer supported.

My findings are that calling the method when it exists is enough. If
not, we are still in beta phase of v3 so we can bring it back if it
turns out that it was necessary.

## Test plan

Tested on expo example on web.

<details>
<summary>Tested on the following Animated.event example:</summary>

```tsx
import * as React from 'react';
import { Animated, Button } from 'react-native';
import {
  GestureHandlerRootView,
  GestureDetector,
  usePanGesture,
} from 'react-native-gesture-handler';

function useAnimatedValue(
  initialValue: number,
  config?: Animated.AnimatedConfig
): Animated.Value {
  const ref = React.useRef<null | Animated.Value>(null);
  if (ref.current == null) {
    ref.current = new Animated.Value(initialValue, config);
  }
  return ref.current;
}

export default function App() {
  const [visible, setVisible] = React.useState(true);

  const value = useAnimatedValue(0);
  const event = Animated.event(
    [{ nativeEvent: { handlerData: { translationX: value } } }],
    {
      useNativeDriver: true,
    }
  );

  const gesture = usePanGesture({
    onUpdate: event,
    useAnimated: true,
  });

  return (
    <GestureHandlerRootView
      style={{ flex: 1, backgroundColor: 'white', paddingTop: 8 }}>
      <Button
        title="Toggle visibility"
        onPress={() => {
          setVisible(!visible);
        }}
      />

      {visible && (
        <GestureDetector gesture={gesture}>
          <Animated.View
            style={[
              {
                width: 150,
                height: 150,
                backgroundColor: 'blue',
                opacity: 0.5,
                borderWidth: 10,
                borderColor: 'green',
                marginTop: 20,
                marginLeft: 40,
              },
              { transform: [{ translateX: value }] },
            ]}
          />
        </GestureDetector>
      )}
    </GestureHandlerRootView>
  );
}
```

</details>

Author: m-bert

packages/react-native-gesture-handler/src/web/handlers/GestureHandler.ts

@@ -404,15 +404,15 @@ export default abstract class GestureHandler implements IGestureHandler {
       return;
     }
 
-    if (usesNativeOrVirtualDetector(this.actionType)) {
-      invokeNullableMethod(
-        this.forReanimated
-          ? onGestureHandlerReanimatedTouchEvent
-          : onGestureHandlerTouchEvent,
-        touchEvent
-      );
+    if (!usesNativeOrVirtualDetector(this.actionType)) {
+      onGestureHandlerEvent?.(touchEvent);
+      return;
+    }
+
+    if (this.forReanimated) {
+      onGestureHandlerReanimatedTouchEvent?.(touchEvent);
     } else {
-      invokeNullableMethod(onGestureHandlerEvent, touchEvent);
+      onGestureHandlerTouchEvent?.(touchEvent);
     }
   }
 
@@ -443,25 +443,26 @@ export default abstract class GestureHandler implements IGestureHandler {
     // However, this may cause trouble in the future (but for now we don't know that)
     if (this.lastSentState !== newState) {
       this.lastSentState = newState;
-      invokeNullableMethod(
-        this.forReanimated
-          ? onGestureHandlerReanimatedStateChange
-          : onGestureHandlerStateChange,
-        resultEvent
-      );
+
+      if (this.forReanimated) {
+        onGestureHandlerReanimatedStateChange?.(resultEvent);
+      } else {
+        onGestureHandlerStateChange?.(resultEvent);
+      }
     }
-    if (this.state === State.ACTIVE) {
-      (resultEvent.nativeEvent as GestureHandlerNativeEvent).oldState =
-        undefined;
-
-      invokeNullableMethod(
-        this.forReanimated
-          ? onGestureHandlerReanimatedEvent
-          : this.forAnimated
-            ? onGestureHandlerAnimatedEvent
-            : onGestureHandlerEvent,
-        resultEvent
-      );
+
+    if (this.state !== State.ACTIVE) {
+      return;
+    }
+
+    (resultEvent.nativeEvent as GestureHandlerNativeEvent).oldState = undefined;
+
+    if (this.forReanimated) {
+      onGestureHandlerReanimatedEvent?.(resultEvent);
+    } else if (this.forAnimated) {
+      onGestureHandlerAnimatedEvent?.(resultEvent);
+    } else {
+      onGestureHandlerEvent?.(resultEvent);
     }
   };
 
@@ -672,15 +673,15 @@ export default abstract class GestureHandler implements IGestureHandler {
       onGestureHandlerTouchEvent,
     }: PropsRef = this.propsRef!.current;
 
-    if (this.actionType === ActionType.NATIVE_DETECTOR) {
-      invokeNullableMethod(
-        this.forReanimated
-          ? onGestureHandlerReanimatedTouchEvent
-          : onGestureHandlerTouchEvent,
-        cancelEvent
-      );
+    if (this.actionType !== ActionType.NATIVE_DETECTOR) {
+      onGestureHandlerEvent?.(cancelEvent);
+      return;
+    }
+
+    if (this.forReanimated) {
+      onGestureHandlerReanimatedTouchEvent?.(cancelEvent);
     } else {
-      invokeNullableMethod(onGestureHandlerEvent, cancelEvent);
+      onGestureHandlerTouchEvent?.(cancelEvent);
     }
   }
 
@@ -1082,58 +1083,3 @@ export default abstract class GestureHandler implements IGestureHandler {
     );
   }
 }
-
-function invokeNullableMethod(
-  method:
-    | ((event: ResultEvent) => void)
-    | { __getHandler: () => (event: ResultEvent) => void }
-    | { __nodeConfig: { argMapping: unknown[] } }
-    | null
-    | undefined,
-  event: ResultEvent
-): void {
-  if (!method) {
-    return;
-  }
-
-  if (typeof method === 'function') {
-    method(event);
-    return;
-  }
-
-  if ('__getHandler' in method && typeof method.__getHandler === 'function') {
-    const handler = method.__getHandler();
-    invokeNullableMethod(handler, event);
-    return;
-  }
-
-  if (!('__nodeConfig' in method)) {
-    return;
-  }
-
-  const { argMapping }: { argMapping: unknown } = method.__nodeConfig;
-  if (!Array.isArray(argMapping)) {
-    return;
-  }
-
-  for (const [index, [key, value]] of argMapping.entries()) {
-    if (!(key in event.nativeEvent)) {
-      continue;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    const nativeValue = (event.nativeEvent as any)[key];
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    if (value?.setValue) {
-      // Reanimated API
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-      value.setValue(nativeValue);
-    } else {
-      // RN Animated API
-      method.__nodeConfig.argMapping[index] = [key, nativeValue];
-    }
-  }
-
-  return;
-}