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

package/src/v3/hooks/gestures/pinch/PinchTypes.ts

@@ -0,0 +1,40 @@
+import type {
+  BaseGestureConfig,
+  ExcludeInternalConfigProps,
+  GestureEvent,
+  SingleGesture,
+} from '../../../types';
+
+export type PinchGestureNativeProperties = Record<string, never>;
+
+// We want to keep `{}` because it does not break ts-server suggestions
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type PinchHandlerData = {};
+
+export type PinchExtendedHandlerData = {
+  scale: number;
+  velocity: number;
+  focalX: number;
+  focalY: number;
+  scaleChange: number;
+};
+
+export type PinchGestureProperties = PinchGestureNativeProperties;
+
+export type PinchGestureInternalConfig = BaseGestureConfig<
+  PinchGestureProperties,
+  PinchHandlerData,
+  PinchExtendedHandlerData
+>;
+
+export type PinchGestureConfig =
+  ExcludeInternalConfigProps<PinchGestureInternalConfig>;
+
+export type PinchGestureEvent = GestureEvent<PinchHandlerData>;
+export type PinchGestureActiveEvent = GestureEvent<PinchExtendedHandlerData>;
+
+export type PinchGesture = SingleGesture<
+  PinchGestureProperties,
+  PinchHandlerData,
+  PinchExtendedHandlerData
+>;

package/src/v3/hooks/gestures/pinch/usePinchGesture.ts

@@ -1,46 +1,22 @@
-import {
-  BaseGestureConfig,
-  ExcludeInternalConfigProps,
-  SingleGesture,
-  HandlerData,
-  SingleGestureName,
-  GestureEvent,
-} from '../../../types';
+import type { GestureEvent, HandlerData } from '../../../types';
+import { SingleGestureName } from '../../../types';
 import { useGesture } from '../../useGesture';
 import {
-  useClonedAndRemappedConfig,
   getChangeEventCalculator,
+  useClonedAndRemappedConfig,
 } from '../../utils';
-import { PinchGestureNativeProperties } from './PinchProperties';
-
-type PinchHandlerData = {
-  scale: number;
-  focalX: number;
-  focalY: number;
-  velocity: number;
-  scaleChange: number;
-};
-
-type PinchGestureProperties = PinchGestureNativeProperties;
-
-type PinchGestureInternalConfig = BaseGestureConfig<
-  PinchHandlerData,
-  PinchGestureProperties
->;
-
-export type PinchGestureConfig =
-  ExcludeInternalConfigProps<PinchGestureInternalConfig>;
-
-export type PinchGestureEvent = GestureEvent<PinchHandlerData>;
-
-export type PinchGesture = SingleGesture<
+import type {
+  PinchExtendedHandlerData,
+  PinchGesture,
+  PinchGestureConfig,
+  PinchGestureInternalConfig,
+  PinchGestureProperties,
   PinchHandlerData,
-  PinchGestureProperties
->;
+} from './PinchTypes';
 
 function diffCalculator(
-  current: HandlerData<PinchHandlerData>,
-  previous: HandlerData<PinchHandlerData> | null
+  current: HandlerData<PinchExtendedHandlerData>,
+  previous: HandlerData<PinchExtendedHandlerData> | null
 ) {
   'worklet';
   return {
@@ -48,10 +24,16 @@ function diffCalculator(
   };
 }
 
+function fillInDefaultValues(event: GestureEvent<PinchExtendedHandlerData>) {
+  'worklet';
+  event.scaleChange = 1;
+}
+
 function transformPinchProps(
   config: PinchGestureConfig & PinchGestureInternalConfig
 ) {
   config.changeEventCalculator = getChangeEventCalculator(diffCalculator);
+  config.fillInDefaultValues = fillInDefaultValues;
 
   return config;
 }
@@ -60,13 +42,12 @@ const PinchPropsMapping = new Map<string, string>();
 
 export function usePinchGesture(config: PinchGestureConfig): PinchGesture {
   const pinchConfig = useClonedAndRemappedConfig<
-    PinchHandlerData,
     PinchGestureProperties,
+    PinchHandlerData,
     // no internal props, pass record as PinchGestureProperties maps everything to never
-    Record<string, unknown>
+    Record<string, unknown>,
+    PinchExtendedHandlerData
   >(config, PinchPropsMapping, transformPinchProps);
 
-  pinchConfig.changeEventCalculator = getChangeEventCalculator(diffCalculator);
-
   return useGesture(SingleGestureName.Pinch, pinchConfig);
 }

package/src/v3/hooks/gestures/rotation/RotationTypes.ts

@@ -0,0 +1,41 @@
+import type {
+  BaseGestureConfig,
+  ExcludeInternalConfigProps,
+  GestureEvent,
+  SingleGesture,
+} from '../../../types';
+
+export type RotationGestureNativeProperties = Record<string, never>;
+
+// We want to keep `{}` because it does not break ts-server suggestions
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type RotationHandlerData = {};
+
+export type RotationExtendedHandlerData = {
+  rotation: number;
+  velocity: number;
+  anchorX: number;
+  anchorY: number;
+  rotationChange: number;
+};
+
+export type RotationGestureProperties = RotationGestureNativeProperties;
+
+export type RotationGestureInternalConfig = BaseGestureConfig<
+  RotationGestureProperties,
+  RotationHandlerData,
+  RotationExtendedHandlerData
+>;
+
+export type RotationGestureConfig =
+  ExcludeInternalConfigProps<RotationGestureInternalConfig>;
+
+export type RotationGestureEvent = GestureEvent<RotationHandlerData>;
+export type RotationGestureActiveEvent =
+  GestureEvent<RotationExtendedHandlerData>;
+
+export type RotationGesture = SingleGesture<
+  RotationGestureProperties,
+  RotationHandlerData,
+  RotationExtendedHandlerData
+>;

package/src/v3/hooks/gestures/rotation/useRotationGesture.ts

@@ -1,46 +1,22 @@
-import {
-  BaseGestureConfig,
-  ExcludeInternalConfigProps,
-  SingleGesture,
-  HandlerData,
-  SingleGestureName,
-  GestureEvent,
-} from '../../../types';
+import type { GestureEvent, HandlerData } from '../../../types';
+import { SingleGestureName } from '../../../types';
 import { useGesture } from '../../useGesture';
 import {
-  useClonedAndRemappedConfig,
   getChangeEventCalculator,
+  useClonedAndRemappedConfig,
 } from '../../utils';
-import { RotationGestureNativeProperties } from './RotationProperties';
-
-type RotationHandlerData = {
-  rotation: number;
-  anchorX: number;
-  anchorY: number;
-  velocity: number;
-  rotationChange: number;
-};
-
-type RotationGestureProperties = RotationGestureNativeProperties;
-
-type RotationGestureInternalConfig = BaseGestureConfig<
+import type {
+  RotationExtendedHandlerData,
+  RotationGesture,
+  RotationGestureConfig,
+  RotationGestureInternalConfig,
+  RotationGestureProperties,
   RotationHandlerData,
-  RotationGestureProperties
->;
-
-export type RotationGestureConfig =
-  ExcludeInternalConfigProps<RotationGestureInternalConfig>;
-
-export type RotationGestureEvent = GestureEvent<RotationHandlerData>;
-
-export type RotationGesture = SingleGesture<
-  RotationHandlerData,
-  RotationGestureProperties
->;
+} from './RotationTypes';
 
 function diffCalculator(
-  current: HandlerData<RotationHandlerData>,
-  previous: HandlerData<RotationHandlerData> | null
+  current: HandlerData<RotationExtendedHandlerData>,
+  previous: HandlerData<RotationExtendedHandlerData> | null
 ) {
   'worklet';
   return {
@@ -50,10 +26,16 @@ function diffCalculator(
   };
 }
 
+function fillInDefaultValues(event: GestureEvent<RotationExtendedHandlerData>) {
+  'worklet';
+  event.rotationChange = 0;
+}
+
 function transformRotationProps(
   config: RotationGestureConfig & RotationGestureInternalConfig
 ) {
   config.changeEventCalculator = getChangeEventCalculator(diffCalculator);
+  config.fillInDefaultValues = fillInDefaultValues;
 
   return config;
 }
@@ -64,10 +46,11 @@ export function useRotationGesture(
   config: RotationGestureConfig
 ): RotationGesture {
   const rotationConfig = useClonedAndRemappedConfig<
-    RotationHandlerData,
     RotationGestureProperties,
+    RotationHandlerData,
     // no internal props, pass record as RotationGestureProperties maps everything to never
-    Record<string, unknown>
+    Record<string, unknown>,
+    RotationExtendedHandlerData
   >(config, RotationPropsMapping, transformRotationProps);
 
   return useGesture(SingleGestureName.Rotation, rotationConfig);

package/src/v3/hooks/gestures/tap/{TapProperties.ts → TapTypes.ts}

@@ -1,3 +1,11 @@
+import type {
+  BaseDiscreteGestureConfig,
+  DiscreteSingleGesture,
+  ExcludeInternalConfigProps,
+  GestureEvent,
+  WithSharedValue,
+} from '../../../types';
+
 type CommonTapGestureConfig = {
   /**
    * Minimum number of pointers (fingers) required to be placed before the
@@ -66,3 +74,27 @@ export const TapNativeProperties = new Set<keyof TapGestureNativeConfig>([
   'maxDelayMs',
   'maxDist',
 ]);
+
+export type TapHandlerData = {
+  x: number;
+  y: number;
+  absoluteX: number;
+  absoluteY: number;
+};
+
+export type TapGestureProperties = WithSharedValue<TapGestureExternalConfig>;
+
+export type TapGestureInternalProperties =
+  WithSharedValue<TapGestureNativeConfig>;
+
+export type TapGestureConfig = ExcludeInternalConfigProps<
+  BaseDiscreteGestureConfig<TapGestureProperties, TapHandlerData>
+>;
+
+export type TapGestureEvent = GestureEvent<TapHandlerData>;
+export type TapGestureActiveEvent = TapGestureEvent;
+
+export type TapGesture = DiscreteSingleGesture<
+  TapGestureInternalProperties,
+  TapHandlerData
+>;

package/src/v3/hooks/gestures/tap/useTapGesture.ts

@@ -1,39 +1,13 @@
-import {
-  BaseDiscreteGestureConfig,
-  ExcludeInternalConfigProps,
-  GestureEvent,
-  DiscreteSingleGesture,
-  SingleGestureName,
-  WithSharedValue,
-} from '../../../types';
+import { SingleGestureName } from '../../../types';
 import { useGesture } from '../../useGesture';
 import { useClonedAndRemappedConfig } from '../../utils';
-import {
-  TapGestureExternalConfig,
-  TapGestureNativeConfig,
-} from './TapProperties';
-
-type TapHandlerData = {
-  x: number;
-  y: number;
-  absoluteX: number;
-  absoluteY: number;
-};
-
-type TapGestureProperties = WithSharedValue<TapGestureExternalConfig>;
-
-type TapGestureInternalProperties = WithSharedValue<TapGestureNativeConfig>;
-
-export type TapGestureConfig = ExcludeInternalConfigProps<
-  BaseDiscreteGestureConfig<TapHandlerData, TapGestureProperties>
->;
-
-export type TapGestureEvent = GestureEvent<TapHandlerData>;
-
-export type TapGesture = DiscreteSingleGesture<
+import type {
+  TapGesture,
+  TapGestureConfig,
+  TapGestureInternalProperties,
+  TapGestureProperties,
   TapHandlerData,
-  TapGestureInternalProperties
->;
+} from './TapTypes';
 
 const TapPropsMapping = new Map<
   keyof TapGestureProperties,
@@ -46,12 +20,12 @@ const TapPropsMapping = new Map<
 
 export function useTapGesture(config: TapGestureConfig): TapGesture {
   const tapConfig = useClonedAndRemappedConfig<
-    TapHandlerData,
     TapGestureProperties,
+    TapHandlerData,
     TapGestureInternalProperties
   >(config, TapPropsMapping);
 
-  return useGesture<TapHandlerData, TapGestureInternalProperties>(
+  return useGesture<TapGestureInternalProperties, TapHandlerData>(
     SingleGestureName.Tap,
     tapConfig
   );

package/src/v3/hooks/useGesture.ts

@@ -1,26 +1,35 @@
 import { useEffect, useMemo, useRef } from 'react';
+
 import { getNextHandlerTag } from '../../handlers/getNextHandlerTag';
+import {
+  registerGesture,
+  unregisterGesture,
+} from '../../handlers/handlersRegistry';
+import { scheduleFlushOperations } from '../../handlers/utils';
+import { tagMessage } from '../../utils';
+import { NativeProxy } from '../NativeProxy';
+import type {
+  BaseGestureConfig,
+  SingleGesture,
+  SingleGestureName,
+} from '../types';
 import { useGestureCallbacks } from './useGestureCallbacks';
 import {
+  bindSharedValues,
   prepareConfig,
+  prepareConfigForNativeSide,
   prepareRelations,
-  bindSharedValues,
   unbindSharedValues,
-  prepareConfigForNativeSide,
 } from './utils';
-import { tagMessage } from '../../utils';
-import { BaseGestureConfig, SingleGesture, SingleGestureName } from '../types';
-import { scheduleFlushOperations } from '../../handlers/utils';
-import {
-  registerGesture,
-  unregisterGesture,
-} from '../../handlers/handlersRegistry';
-import { NativeProxy } from '../NativeProxy';
 
-export function useGesture<THandlerData, TConfig>(
+export function useGesture<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+>(
   type: SingleGestureName,
-  config: BaseGestureConfig<THandlerData, TConfig>
-): SingleGesture<THandlerData, TConfig> {
+  config: BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>
+): SingleGesture<TConfig, THandlerData, TExtendedHandlerData> {
   const handlerTag = useMemo(() => getNextHandlerTag(), []);
   const disableReanimated = useMemo(() => config.disableReanimated, []);
 
@@ -90,6 +99,10 @@ export function useGesture<THandlerData, TConfig>(
 
   useEffect(() => {
     return () => {
+      if (currentGestureRef.current.handlerTag === handlerTag) {
+        currentGestureRef.current = { type: '', handlerTag: -1 };
+      }
+
       NativeProxy.dropGestureHandler(handlerTag);
       scheduleFlushOperations();
     };

package/src/v3/hooks/useGestureCallbacks.ts

@@ -1,17 +1,17 @@
-import { useGestureEventHandler } from './callbacks/useGestureEventHandler';
-import {
+import { Reanimated } from '../../handlers/gestures/reanimatedWrapper';
+import { tagMessage } from '../../utils';
+import type {
   AnimatedEvent,
   BaseGestureConfig,
   GestureUpdateEventWithHandlerData,
 } from '../types';
+import { useGestureEventHandler } from './callbacks/useGestureEventHandler';
+import { useReanimatedEventHandler } from './callbacks/useReanimatedEventHandler';
 import {
   checkMappingForChangeProperties,
   isNativeAnimatedEvent,
   useMemoizedGestureCallbacks,
 } from './utils';
-import { useReanimatedEventHandler } from './callbacks/useReanimatedEventHandler';
-import { tagMessage } from '../../utils';
-import { Reanimated } from '../../handlers/gestures/reanimatedWrapper';
 
 function guardJSAnimatedEvent(handler: (...args: unknown[]) => void) {
   return (...args: unknown[]) => {
@@ -36,9 +36,13 @@ function guardJSAnimatedEvent(handler: (...args: unknown[]) => void) {
   };
 }
 
-export function useGestureCallbacks<THandlerData, TConfig>(
+export function useGestureCallbacks<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>(
   handlerTag: number,
-  config: BaseGestureConfig<THandlerData, TConfig>
+  config: BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>
 ) {
   const callbacks = useMemoizedGestureCallbacks(config);
 
@@ -54,12 +58,13 @@ export function useGestureCallbacks<THandlerData, TConfig>(
       handlerTag,
       callbacks,
       reanimatedHandler,
-      config.changeEventCalculator
+      config.changeEventCalculator,
+      config.fillInDefaultValues
     );
   }
 
   let animatedEventHandler:
-    | ((event: GestureUpdateEventWithHandlerData<THandlerData>) => void)
+    | ((event: GestureUpdateEventWithHandlerData<TExtendedHandlerData>) => void)
     | AnimatedEvent
     | undefined;
   if (config.dispatchesAnimatedEvents) {

package/src/v3/hooks/utils/configUtils.ts

@@ -1,11 +1,12 @@
+import { useMemo } from 'react';
+
 import { Reanimated } from '../../../handlers/gestures/reanimatedWrapper';
 import { tagMessage } from '../../../utils';
-import {
+import type {
   BaseGestureConfig,
   ExcludeInternalConfigProps,
   SingleGestureName,
 } from '../../types';
-import { hasWorkletEventHandlers, maybeUnpackValue } from './reanimatedUtils';
 import { isNativeAnimatedEvent, shouldHandleTouchEvents } from './eventUtils';
 import {
   allowedNativeProps,
@@ -13,11 +14,13 @@ import {
   PropsToFilter,
   PropsWhiteLists,
 } from './propsWhiteList';
-import { useMemo } from 'react';
+import { hasWorkletEventHandlers, maybeUnpackValue } from './reanimatedUtils';
 
-export function prepareConfig<THandlerData, TConfig extends object>(
-  config: BaseGestureConfig<THandlerData, TConfig>
-) {
+export function prepareConfig<
+  TConfig extends object,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>(config: BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>) {
   const runOnJS = maybeUnpackValue(config.runOnJS);
 
   if (
@@ -64,12 +67,20 @@ export function prepareConfig<THandlerData, TConfig extends object>(
     config.shouldUseReanimatedDetector && !runOnJS;
 }
 
-export function prepareConfigForNativeSide<THandlerData, TConfig>(
+export function prepareConfigForNativeSide<
+  TConfig extends object,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>(
   handlerType: SingleGestureName,
-  config: BaseGestureConfig<THandlerData, TConfig>
+  config: BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>
 ) {
   // @ts-ignore Seems like TypeScript can't infer the type here properly because of generic
-  const filteredConfig: BaseGestureConfig<THandlerData, TConfig> = {};
+  const filteredConfig: BaseGestureConfig<
+    TConfig,
+    THandlerData,
+    TExtendedHandlerData
+  > = {};
   const handlerPropsWhiteList =
     PropsWhiteLists.get(handlerType) ?? EMPTY_WHITE_LIST;
 
@@ -93,10 +104,20 @@ export function prepareConfigForNativeSide<THandlerData, TConfig>(
   return filteredConfig;
 }
 
-function cloneConfig<THandlerData, TConfig>(
-  config: ExcludeInternalConfigProps<BaseGestureConfig<THandlerData, TConfig>>
-): BaseGestureConfig<THandlerData, TConfig> {
-  return { ...config } as BaseGestureConfig<THandlerData, TConfig>;
+function cloneConfig<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>(
+  config: ExcludeInternalConfigProps<
+    BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>
+  >
+): BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData> {
+  return { ...config } as BaseGestureConfig<
+    TConfig,
+    THandlerData,
+    TExtendedHandlerData
+  >;
 }
 
 function remapProps<
@@ -122,16 +143,23 @@ function remapProps<
 }
 
 export function useClonedAndRemappedConfig<
+  TConfig extends Record<string, unknown>,
   THandlerData,
-  TConfig extends object,
-  TInternalConfig extends Record<string, unknown>,
+  TInternalConfig extends Record<string, unknown> = TConfig,
+  TExtendedHandlerData extends THandlerData = THandlerData,
 >(
-  config: ExcludeInternalConfigProps<BaseGestureConfig<THandlerData, TConfig>>,
+  config: ExcludeInternalConfigProps<
+    BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>
+  >,
   propsMapping: Map<string, string> = new Map(),
   propsTransformer: (config: TInternalConfig) => TInternalConfig = (cfg) => cfg
-): BaseGestureConfig<THandlerData, TInternalConfig> {
+): BaseGestureConfig<TInternalConfig, THandlerData, TExtendedHandlerData> {
   return useMemo(() => {
-    const clonedConfig = cloneConfig<THandlerData, TConfig>(config);
+    const clonedConfig = cloneConfig<
+      TConfig,
+      THandlerData,
+      TExtendedHandlerData
+    >(config);
 
     return propsTransformer(
       remapProps<TConfig, TInternalConfig>(

package/src/v3/hooks/utils/eventHandlersUtils.ts

@@ -1,17 +1,21 @@
 import { useMemo } from 'react';
-import { TouchEventType } from '../../../TouchEventType';
+
 import { CALLBACK_TYPE } from '../../../handlers/gestures/gesture';
-import {
+import { TouchEventType } from '../../../TouchEventType';
+import type {
   GestureCallbacks,
+  GestureEndEventCallback,
   GestureEventCallback,
-  GestureEventCallbackWithDidSucceed,
   GestureTouchEventCallback,
   UnpackedGestureHandlerEvent,
 } from '../../types';
 
-export function useMemoizedGestureCallbacks<THandlerData>(
-  callbacks: GestureCallbacks<THandlerData>
-): GestureCallbacks<THandlerData> {
+export function useMemoizedGestureCallbacks<
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>(
+  callbacks: GestureCallbacks<THandlerData, TExtendedHandlerData>
+): GestureCallbacks<THandlerData, TExtendedHandlerData> {
   return useMemo(
     () => ({
       ...(callbacks.onBegin ? { onBegin: callbacks.onBegin } : {}),
@@ -46,12 +50,14 @@ export function useMemoizedGestureCallbacks<THandlerData>(
   );
 }
 
-function getHandler<THandlerData>(
+function getHandler<THandlerData, TExtendedHandlerData extends THandlerData>(
   type: CALLBACK_TYPE,
-  callbacks: GestureCallbacks<THandlerData>
+  callbacks: GestureCallbacks<THandlerData, TExtendedHandlerData>
 ):
   | GestureEventCallback<THandlerData>
-  | GestureEventCallbackWithDidSucceed<THandlerData>
+  | GestureEventCallback<TExtendedHandlerData>
+  | GestureEndEventCallback<THandlerData>
+  | GestureEndEventCallback<TExtendedHandlerData>
   | GestureTouchEventCallback
   | undefined {
   'worklet';
@@ -61,7 +67,7 @@ function getHandler<THandlerData>(
     case CALLBACK_TYPE.START:
       return callbacks.onActivate;
     case CALLBACK_TYPE.UPDATE:
-      return callbacks.onUpdate as GestureEventCallback<THandlerData>; // Animated event is handled in different place.
+      return callbacks.onUpdate as GestureEventCallback<TExtendedHandlerData>; // Animated event is handled in different place.
     case CALLBACK_TYPE.END:
       return callbacks.onDeactivate;
     case CALLBACK_TYPE.FINALIZE:
@@ -95,13 +101,14 @@ export function touchEventTypeToCallbackType(
 }
 
 type SingleParameterCallback<T> = (event: T) => void;
-type DoubleParameterCallback<T> = (event: T, didSucceed: boolean) => void;
 
-export function runCallback<THandlerData>(
+export function runCallback<
+  THandlerData,
+  TExtendedHandlerData extends THandlerData,
+>(
   type: CALLBACK_TYPE,
-  callbacks: GestureCallbacks<THandlerData>,
-  event: UnpackedGestureHandlerEvent<THandlerData>,
-  didSucceed?: boolean
+  callbacks: GestureCallbacks<THandlerData, TExtendedHandlerData>,
+  event: UnpackedGestureHandlerEvent<THandlerData>
 ) {
   'worklet';
   const handler = getHandler(type, callbacks);
@@ -110,9 +117,5 @@ export function runCallback<THandlerData>(
     return;
   }
 
-  if (didSucceed === undefined) {
-    (handler as SingleParameterCallback<typeof event>)(event);
-  } else {
-    (handler as DoubleParameterCallback<typeof event>)(event, didSucceed);
-  }
+  (handler as SingleParameterCallback<typeof event>)(event);
 }