react-native-gesture-handler 3.0.0-beta.2 → 3.0.0-beta.3

package/src/v3/createNativeWrapper.tsx

@@ -1,26 +1,24 @@
 import React, { useEffect } from 'react';
 
-import { NativeWrapperProps } from './hooks/utils';
-import { useNativeGesture } from './hooks/gestures';
-import { NativeDetector } from './detectors/NativeDetector';
-import type { NativeWrapperProperties } from './types/NativeWrapperType';
-import { NativeGesture } from './hooks/gestures/native/useNativeGesture';
 import { GestureDetectorType, InterceptingGestureDetector } from './detectors';
+import { NativeDetector } from './detectors/NativeDetector';
 import { VirtualDetector } from './detectors/VirtualDetector/VirtualDetector';
+import { useNativeGesture } from './hooks/gestures';
+import { NativeWrapperProps } from './hooks/utils';
+import type {
+  NativeWrapperProperties,
+  WrapperSpecificProperties,
+} from './types/NativeWrapperType';
 
-export default function createNativeWrapper<P>(
-  Component: React.ComponentType<P>,
-  config: Readonly<NativeWrapperProperties> = {},
+export default function createNativeWrapper<TRef = unknown, TProps = unknown>(
+  Component: React.ComponentType<TProps>,
+  config: Readonly<
+    Omit<NativeWrapperProperties<TRef>, keyof WrapperSpecificProperties<TRef>>
+  > = {},
   detectorType: GestureDetectorType = GestureDetectorType.Native
 ) {
   const ComponentWrapper = (
-    props: P &
-      NativeWrapperProperties & {
-        ref?: React.RefObject<unknown>;
-        onGestureUpdate_CAN_CAUSE_INFINITE_RERENDER?: (
-          gesture: NativeGesture
-        ) => void;
-      }
+    props: TProps & NativeWrapperProperties<TRef | null>
   ) => {
     const { ref, onGestureUpdate_CAN_CAUSE_INFINITE_RERENDER, ...restProps } =
       props;
@@ -43,7 +41,7 @@ export default function createNativeWrapper<P>(
           enabled: props.enabled,
           hitSlop: props.hitSlop,
           testID: props.testID,
-        } as P,
+        } as TProps,
       }
     );
 

package/src/v3/detectors/GestureDetector.tsx

@@ -1,15 +1,19 @@
-import { NativeDetectorProps } from './common';
 import { BaseGesture } from '../../handlers/gestures/gesture';
-import { NativeDetector } from './NativeDetector';
 import { ComposedGesture } from '../../handlers/gestures/gestureComposition';
-import {
-  GestureDetectorProps as LegacyGestureDetectorProps,
-  GestureDetector as LegacyGestureDetector,
-} from '../../handlers/gestures/GestureDetector';
+import type { GestureDetectorProps as LegacyGestureDetectorProps } from '../../handlers/gestures/GestureDetector';
+import { GestureDetector as LegacyGestureDetector } from '../../handlers/gestures/GestureDetector';
+import type { NativeDetectorProps } from './common';
+import { NativeDetector } from './NativeDetector';
 import { useEnsureGestureHandlerRootView } from './useEnsureGestureHandlerRootView';
 
-export function GestureDetector<THandlerData, TConfig>(
-  props: NativeDetectorProps<THandlerData, TConfig> | LegacyGestureDetectorProps
+export function GestureDetector<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>(
+  props:
+    | NativeDetectorProps<TConfig, THandlerData, TExtendedHandlerData>
+    | LegacyGestureDetectorProps
 ) {
   useEnsureGestureHandlerRootView();
 
@@ -22,7 +26,11 @@ export function GestureDetector<THandlerData, TConfig>(
 
   return (
     <NativeDetector
-      {...(props as NativeDetectorProps<THandlerData, TConfig>)}
+      {...(props as NativeDetectorProps<
+        TConfig,
+        THandlerData,
+        TExtendedHandlerData
+      >)}
     />
   );
 }

package/src/v3/detectors/HostGestureDetector.web.tsx

@@ -1,25 +1,33 @@
-import React, { Ref, RefObject, useEffect, useMemo, useRef } from 'react';
-import RNGestureHandlerModule from '../../RNGestureHandlerModule.web';
-import { ActionType } from '../../ActionType';
-import { PropsRef } from '../../web/interfaces';
+import type { Ref, RefObject } from 'react';
+import React, { useEffect, useMemo, useRef } from 'react';
 import { View } from 'react-native';
+
+import { ActionType } from '../../ActionType';
+import type {
+  TouchAction,
+  UserSelect,
+} from '../../handlers/gestureHandlerCommon';
+import RNGestureHandlerModule from '../../RNGestureHandlerModule.web';
 import { tagMessage } from '../../utils';
-import { TouchAction, UserSelect } from '../../handlers/gestureHandlerCommon';
+import type { PropsRef } from '../../web/interfaces';
 
 export interface GestureHandlerDetectorProps extends PropsRef {
   handlerTags: number[];
   moduleId: number;
   children?: React.ReactNode;
   virtualChildren?: Set<VirtualChildrenWeb>;
-  userSelect?: UserSelect;
-  touchAction?: TouchAction;
-  enableContextMenu?: boolean;
+  userSelect?: UserSelect | undefined;
+  touchAction?: TouchAction | undefined;
+  enableContextMenu?: boolean | undefined;
 }
 
 export interface VirtualChildrenWeb {
   viewTag: number;
   handlerTags: number[];
   viewRef: RefObject<Element | null>;
+  userSelect?: UserSelect | undefined;
+  touchAction?: TouchAction | undefined;
+  enableContextMenu?: boolean | undefined;
 }
 
 const EMPTY_HANDLERS = new Set<number>();
@@ -62,6 +70,14 @@ const HostGestureDetector = (props: GestureHandlerDetectorProps) => {
         ).shouldAttachGestureToChildView() &&
         actionType === ActionType.NATIVE_DETECTOR
       ) {
+        if (viewRef.current!.childElementCount > 1) {
+          throw new Error(
+            tagMessage(
+              'Cannot have more than one child view when native gesture handlers are attached to the detector'
+            )
+          );
+        }
+
         RNGestureHandlerModule.attachGestureHandler(
           tag,
           viewRef.current!.firstChild,
@@ -107,20 +123,6 @@ const HostGestureDetector = (props: GestureHandlerDetectorProps) => {
   }, [props]);
 
   useEffect(() => {
-    if (React.Children.count(children) !== 1) {
-      throw new Error(
-        tagMessage('Detector expected to have exactly one child element')
-      );
-    }
-  }, [children]);
-
-  useEffect(() => {
-    if (React.Children.count(children) !== 1) {
-      throw new Error(
-        tagMessage('Detector expected to have exactly one child element')
-      );
-    }
-
     detachHandlers(handlerTagsSet, attachedHandlers.current);
 
     attachHandlers(
@@ -174,6 +176,14 @@ const HostGestureDetector = (props: GestureHandlerDetectorProps) => {
         attachedVirtualHandlers.current.get(child.viewTag)!,
         ActionType.VIRTUAL_DETECTOR
       );
+
+      currentHandlerTags.forEach((tag) => {
+        RNGestureHandlerModule.updateGestureHandlerConfig(tag, {
+          userSelect: child.userSelect,
+          touchAction: child.touchAction,
+          enableContextMenu: child.enableContextMenu,
+        });
+      });
     });
   }, [props.virtualChildren]);
 

package/src/v3/detectors/NativeDetector.tsx

@@ -1,22 +1,24 @@
 import React, { useMemo } from 'react';
-import HostGestureDetector from './HostGestureDetector';
-import { configureRelations, ensureNativeDetectorComponent } from './utils';
+import { Platform } from 'react-native';
+
 import { isComposedGesture } from '../hooks/utils/relationUtils';
-import {
-  AnimatedNativeDetector,
-  NativeDetectorProps,
-  nativeDetectorStyles,
-} from './common';
+import type { NativeDetectorProps } from './common';
+import { AnimatedNativeDetector, nativeDetectorStyles } from './common';
+import HostGestureDetector from './HostGestureDetector';
 import { ReanimatedNativeDetector } from './ReanimatedNativeDetector';
-import { Platform } from 'react-native';
+import { configureRelations, ensureNativeDetectorComponent } from './utils';
 
-export function NativeDetector<THandlerData, TConfig>({
+export function NativeDetector<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>({
   gesture,
   children,
   touchAction,
   userSelect,
   enableContextMenu,
-}: NativeDetectorProps<THandlerData, TConfig>) {
+}: NativeDetectorProps<TConfig, THandlerData, TExtendedHandlerData>) {
   const NativeDetectorComponent = gesture.config.dispatchesAnimatedEvents
     ? AnimatedNativeDetector
     : gesture.config.shouldUseReanimatedDetector

package/src/v3/detectors/ReanimatedNativeDetector.tsx

@@ -1,12 +1,11 @@
 import { useEffect, useMemo, useRef } from 'react';
-import {
-  NativeEventsManager,
-  Reanimated,
-} from '../../handlers/gestures/reanimatedWrapper';
+import { findNodeHandle } from 'react-native';
+
+import type { NativeEventsManager } from '../../handlers/gestures/reanimatedWrapper';
+import { Reanimated } from '../../handlers/gestures/reanimatedWrapper';
 import HostGestureDetector, {
   type RNGestureHandlerDetectorNativeComponentProps,
 } from './HostGestureDetector';
-import { findNodeHandle } from 'react-native';
 
 let NativeEventsManagerImpl = Reanimated?.NativeEventsManager;
 

package/src/v3/detectors/VirtualDetector/InterceptingGestureDetector.tsx

@@ -1,53 +1,74 @@
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import HostGestureDetector from '../HostGestureDetector';
-import {
-  VirtualChild,
-  GestureHandlerEventWithHandlerData,
+import { Platform } from 'react-native';
+
+import type {
+  TouchAction,
+  UserSelect,
+} from '../../../handlers/gestureHandlerCommon';
+import { Reanimated } from '../../../handlers/gestures/reanimatedWrapper';
+import { tagMessage } from '../../../utils';
+import { isComposedGesture } from '../../hooks/utils/relationUtils';
+import type {
   DetectorCallbacks,
+  GestureHandlerEventWithHandlerData,
+  VirtualChild,
 } from '../../types';
+import type { InterceptingGestureDetectorProps } from '../common';
+import { AnimatedNativeDetector, nativeDetectorStyles } from '../common';
+import HostGestureDetector from '../HostGestureDetector';
+import { ReanimatedNativeDetector } from '../ReanimatedNativeDetector';
+import { useEnsureGestureHandlerRootView } from '../useEnsureGestureHandlerRootView';
+import { configureRelations, ensureNativeDetectorComponent } from '../utils';
+import type { InterceptingDetectorContextValue } from './useInterceptingDetectorContext';
 import {
   InterceptingDetectorContext,
-  InterceptingDetectorContextValue,
   InterceptingDetectorMode,
 } from './useInterceptingDetectorContext';
-import { Reanimated } from '../../../handlers/gestures/reanimatedWrapper';
-import { configureRelations, ensureNativeDetectorComponent } from '../utils';
-import { isComposedGesture } from '../../hooks/utils/relationUtils';
-import {
-  AnimatedNativeDetector,
-  InterceptingGestureDetectorProps,
-  nativeDetectorStyles,
-} from '../common';
-import { tagMessage } from '../../../utils';
-import { useEnsureGestureHandlerRootView } from '../useEnsureGestureHandlerRootView';
-import { ReanimatedNativeDetector } from '../ReanimatedNativeDetector';
-import { Platform } from 'react-native';
 
-interface VirtualChildrenForNative {
+interface StrippedVirtualChildren {
   viewTag: number;
   handlerTags: number[];
-  viewRef: unknown;
+  viewRef?: unknown;
+  userSelect?: UserSelect;
+  touchAction?: TouchAction;
+  enableContextMenu?: boolean;
 }
 
-export function InterceptingGestureDetector<THandlerData, TConfig>({
+export function InterceptingGestureDetector<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>({
   gesture,
   children,
   touchAction,
   userSelect,
   enableContextMenu,
-}: InterceptingGestureDetectorProps<THandlerData, TConfig>) {
+}: InterceptingGestureDetectorProps<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData
+>) {
   useEnsureGestureHandlerRootView();
 
   const [virtualChildren, setVirtualChildren] = useState<Set<VirtualChild>>(
     () => new Set()
   );
-  const virtualChildrenForNativeComponent: VirtualChildrenForNative[] = useMemo(
+  const strippedVirtualChildren: StrippedVirtualChildren[] = useMemo(
     () =>
-      Array.from(virtualChildren).map((child) => ({
-        viewTag: child.viewTag,
-        handlerTags: child.handlerTags,
-        viewRef: child.viewRef,
-      })),
+      Platform.OS === 'web'
+        ? Array.from(virtualChildren).map((child) => ({
+            viewTag: child.viewTag,
+            handlerTags: child.handlerTags,
+            viewRef: child.viewRef,
+            userSelect: child.userSelect,
+            touchAction: child.touchAction,
+            enableContextMenu: child.enableContextMenu,
+          }))
+        : Array.from(virtualChildren).map((child) => ({
+            viewTag: child.viewTag,
+            handlerTags: child.handlerTags,
+          })),
     [virtualChildren]
   );
   const [mode, setMode] = useState<InterceptingDetectorMode>(
@@ -131,8 +152,13 @@ export function InterceptingGestureDetector<THandlerData, TConfig>({
   }
 
   const createGestureEventHandler = useCallback(
-    (key: keyof DetectorCallbacks<THandlerData>) => {
-      return (e: GestureHandlerEventWithHandlerData<THandlerData>) => {
+    (key: keyof DetectorCallbacks<THandlerData, TExtendedHandlerData>) => {
+      return (
+        e: GestureHandlerEventWithHandlerData<
+          THandlerData,
+          TExtendedHandlerData
+        >
+      ) => {
         if (typeof gesture?.detectorCallbacks[key] === 'function') {
           // @ts-expect-error passing event to a union of functions where only one is typed as such
           gesture.detectorCallbacks[key](e);
@@ -151,15 +177,18 @@ export function InterceptingGestureDetector<THandlerData, TConfig>({
   );
 
   const getHandlers = useCallback(
-    (key: keyof DetectorCallbacks<unknown>) => {
+    (key: keyof DetectorCallbacks<unknown, unknown>) => {
       const handlers: ((
-        e: GestureHandlerEventWithHandlerData<THandlerData>
+        e: GestureHandlerEventWithHandlerData<
+          THandlerData,
+          TExtendedHandlerData
+        >
       ) => void)[] = [];
 
       if (gesture?.detectorCallbacks[key]) {
         handlers.push(
           gesture.detectorCallbacks[key] as (
-            e: GestureHandlerEventWithHandlerData<unknown>
+            e: GestureHandlerEventWithHandlerData<unknown, unknown>
           ) => void
         );
       }
@@ -169,7 +198,10 @@ export function InterceptingGestureDetector<THandlerData, TConfig>({
         if (handler) {
           handlers.push(
             handler as (
-              e: GestureHandlerEventWithHandlerData<THandlerData>
+              e: GestureHandlerEventWithHandlerData<
+                THandlerData,
+                TExtendedHandlerData
+              >
             ) => void
           );
         }
@@ -261,7 +293,7 @@ export function InterceptingGestureDetector<THandlerData, TConfig>({
         }
         handlerTags={handlerTags}
         style={nativeDetectorStyles.detector}
-        virtualChildren={virtualChildrenForNativeComponent}
+        virtualChildren={strippedVirtualChildren}
         moduleId={globalThis._RNGH_MODULE_ID}>
         {children}
       </NativeDetectorComponent>

package/src/v3/detectors/VirtualDetector/VirtualDetector.tsx

@@ -1,15 +1,16 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { Wrap } from '../../../handlers/gestures/GestureDetector/Wrap';
 import { findNodeHandle, Platform } from 'react-native';
+
+import { Wrap } from '../../../handlers/gestures/GestureDetector/Wrap';
+import { tagMessage } from '../../../utils';
+import { isComposedGesture } from '../../hooks/utils/relationUtils';
+import type { DetectorCallbacks, VirtualChild } from '../../types';
+import type { VirtualDetectorProps } from '../common';
+import { configureRelations } from '../utils';
 import {
   InterceptingDetectorMode,
   useInterceptingDetectorContext,
 } from './useInterceptingDetectorContext';
-import { isComposedGesture } from '../../hooks/utils/relationUtils';
-import { VirtualDetectorProps } from '../common';
-import { configureRelations } from '../utils';
-import { tagMessage } from '../../../utils';
-import { DetectorCallbacks, VirtualChild } from '../../types';
 
 function useRequiredInterceptingDetectorContext() {
   const context = useInterceptingDetectorContext();
@@ -23,9 +24,11 @@ function useRequiredInterceptingDetectorContext() {
   return context;
 }
 
-export function VirtualDetector<THandlerData, TConfig>(
-  props: VirtualDetectorProps<THandlerData, TConfig>
-) {
+export function VirtualDetector<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>(props: VirtualDetectorProps<TConfig, THandlerData, TExtendedHandlerData>) {
   // Don't memoize virtual detectors to be able to listen to changes in children
   // TODO: replace with MutationObserver when it rolls out in React Native
   'use no memo';
@@ -73,17 +76,30 @@ export function VirtualDetector<THandlerData, TConfig>(
     const virtualChild: VirtualChild = {
       viewTag,
       handlerTags,
-      methods: props.gesture.detectorCallbacks as DetectorCallbacks<unknown>,
+      methods: props.gesture.detectorCallbacks as DetectorCallbacks<
+        unknown,
+        unknown
+      >,
       // used by HostGestureDetector on web
       viewRef: Platform.OS === 'web' ? viewRef : undefined,
+      userSelect: props.userSelect,
+      touchAction: props.touchAction,
+      enableContextMenu: props.enableContextMenu,
     };
-
     register(virtualChild);
-
     return () => {
       unregister(virtualChild);
     };
-  }, [viewTag, props.gesture, register, unregister, setMode]);
+  }, [
+    viewTag,
+    props.gesture,
+    props.userSelect,
+    props.touchAction,
+    props.enableContextMenu,
+    register,
+    unregister,
+    setMode,
+  ]);
 
   configureRelations(props.gesture);
 

package/src/v3/detectors/VirtualDetector/useInterceptingDetectorContext.ts

@@ -1,5 +1,6 @@
 import { createContext, use } from 'react';
-import { VirtualChild } from '../../types';
+
+import type { VirtualChild } from '../../types';
 
 export enum InterceptingDetectorMode {
   DEFAULT,

package/src/v3/detectors/common.ts

@@ -1,9 +1,13 @@
-import React from 'react';
-import { Gesture } from '../types';
+import type React from 'react';
 import { Animated, StyleSheet } from 'react-native';
+
+import type {
+  TouchAction,
+  UserSelect,
+} from '../../handlers/gestureHandlerCommon';
+import type { GestureDetectorProps as LegacyDetectorProps } from '../../handlers/gestures/GestureDetector';
+import type { Gesture } from '../types';
 import HostGestureDetector from './HostGestureDetector';
-import { GestureDetectorProps as LegacyDetectorProps } from '../../handlers/gestures/GestureDetector';
-import { TouchAction, UserSelect } from '../../handlers/gestureHandlerCommon';
 
 export enum GestureDetectorType {
   Native,
@@ -13,30 +17,46 @@ export enum GestureDetectorType {
 
 interface CommonGestureDetectorProps {
   children?: React.ReactNode;
-  userSelect?: UserSelect;
-  touchAction?: TouchAction;
-  enableContextMenu?: boolean;
+  userSelect?: UserSelect | undefined;
+  touchAction?: TouchAction | undefined;
+  enableContextMenu?: boolean | undefined;
 }
 
-export interface NativeDetectorProps<THandlerData, TConfig>
-  extends CommonGestureDetectorProps {
-  gesture: Gesture<THandlerData, TConfig>;
+export interface NativeDetectorProps<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+> extends CommonGestureDetectorProps {
+  gesture: Gesture<TConfig, THandlerData, TExtendedHandlerData>;
 }
 
-export interface InterceptingGestureDetectorProps<THandlerData, TConfig>
-  extends CommonGestureDetectorProps {
-  gesture?: Gesture<THandlerData, TConfig>;
+export interface InterceptingGestureDetectorProps<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+> extends CommonGestureDetectorProps {
+  gesture?: Gesture<TConfig, THandlerData, TExtendedHandlerData>;
 }
 
-// TODO: Handle CommonGestureDetectorProps inside VirtualGestureDetector
-export interface VirtualDetectorProps<THandlerData, TConfig> {
-  children?: React.ReactNode;
-  gesture: Gesture<THandlerData, TConfig>;
+export interface VirtualDetectorProps<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+> extends CommonGestureDetectorProps {
+  gesture: Gesture<TConfig, THandlerData, TExtendedHandlerData>;
 }
 
-export type GestureDetectorProps<THandlerData, TConfig> =
-  | NativeDetectorProps<THandlerData, TConfig>
-  | InterceptingGestureDetectorProps<THandlerData, TConfig>
+export type GestureDetectorProps<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+> =
+  | NativeDetectorProps<TConfig, THandlerData, TExtendedHandlerData>
+  | InterceptingGestureDetectorProps<
+      TConfig,
+      THandlerData,
+      TExtendedHandlerData
+    >
   | LegacyDetectorProps;
 
 export const AnimatedNativeDetector =

package/src/v3/detectors/index.ts

@@ -1,5 +1,5 @@
 export type { GestureDetectorProps } from './common';
 export { GestureDetectorType } from './common';
 export { GestureDetector } from './GestureDetector';
-export { VirtualDetector as VirtualGestureDetector } from './VirtualDetector/VirtualDetector';
 export { InterceptingGestureDetector } from './VirtualDetector/InterceptingGestureDetector';
+export { VirtualDetector as VirtualGestureDetector } from './VirtualDetector/VirtualDetector';

package/src/v3/detectors/useEnsureGestureHandlerRootView.ts

@@ -1,5 +1,6 @@
 import { use } from 'react';
 import { Platform } from 'react-native';
+
 import GestureHandlerRootViewContext from '../../GestureHandlerRootViewContext';
 
 export function useEnsureGestureHandlerRootView() {

package/src/v3/detectors/utils.ts

@@ -10,7 +10,8 @@ import {
   prepareRelations,
 } from '../hooks/utils/relationUtils';
 import { NativeProxy } from '../NativeProxy';
-import { ComposedGestureName, Gesture } from '../types';
+import type { Gesture } from '../types';
+import { ComposedGestureName } from '../types';
 
 // The tree consists of ComposedGestures and NativeGestures. NativeGestures are always leaf nodes.
 export const traverseAndConfigureRelations = (
@@ -135,8 +136,8 @@ export const traverseAndConfigureRelations = (
   });
 };
 
-export function configureRelations<THandlerData, TConfig>(
-  gesture: Gesture<THandlerData, TConfig>
+export function configureRelations<TConfig, THandlerData>(
+  gesture: Gesture<TConfig, THandlerData>
 ) {
   if (isComposedGesture(gesture)) {
     const simultaneousHandlers = new Set<number>(

package/src/v3/gestureStateManager.ts

@@ -2,7 +2,6 @@ import { State } from '../State';
 import { tagMessage } from '../utils';
 
 export type GestureStateManagerType = {
-  begin(handlerTag: number): void;
   activate(handlerTag: number): void;
   fail(handlerTag: number): void;
   deactivate(handlerTag: number): void;
@@ -21,11 +20,6 @@ const setGestureState = (handlerTag: number, state: State) => {
 };
 
 export const GestureStateManager: GestureStateManagerType = {
-  begin(handlerTag: number) {
-    'worklet';
-    setGestureState(handlerTag, State.BEGAN);
-  },
-
   activate(handlerTag: number) {
     'worklet';
     setGestureState(handlerTag, State.ACTIVE);

package/src/v3/gestureStateManager.web.ts

@@ -1,9 +1,8 @@
-import { State } from '../State';
 import { tagMessage } from '../utils';
-import IGestureHandler from '../web/handlers/IGestureHandler';
+import type IGestureHandler from '../web/handlers/IGestureHandler';
 import GestureHandlerOrchestrator from '../web/tools/GestureHandlerOrchestrator';
 import NodeManager from '../web/tools/NodeManager';
-import { GestureStateManagerType } from './gestureStateManager';
+import type { GestureStateManagerType } from './gestureStateManager';
 
 function ensureHandlerAttached(handler: IGestureHandler) {
   if (!handler.attached) {
@@ -16,24 +15,10 @@ function ensureHandlerAttached(handler: IGestureHandler) {
 }
 
 export const GestureStateManager: GestureStateManagerType = {
-  begin(handlerTag: number): void {
-    'worklet';
-    const handler = NodeManager.getHandler(handlerTag);
-    ensureHandlerAttached(handler);
-
-    GestureHandlerOrchestrator.instance.recordHandlerIfNotPresent(handler);
-    handler.begin();
-  },
-
   activate(handlerTag: number): void {
     'worklet';
     const handler = NodeManager.getHandler(handlerTag);
     ensureHandlerAttached(handler);
-    // Force going from UNDETERMINED to ACTIVE through BEGAN to preserve
-    // the correct state transition flow.
-    if (handler.state === State.UNDETERMINED) {
-      handler.begin();
-    }
 
     GestureHandlerOrchestrator.instance.recordHandlerIfNotPresent(handler);
     handler.activate(true);