@react-native-oh-tpl/react-native-gesture-handler 2.12.6-2 → 2.12.9

package/harmony/gesture_handler/src/main/ets/GestureHandler.ts

@@ -324,7 +324,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     return this.view
   }
 
-  protected begin(): void {
+  public begin(): void {
     this.logger.info("begin")
     if (!this.isWithinHitSlop()) return;
     if (this.currentState === State.UNDETERMINED) {
@@ -401,7 +401,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     return false;
   }
 
-  protected activate(): void {
+  public activate(): void {
     this.logger.info("activate")
     if (this.currentState === State.UNDETERMINED || this.currentState === State.BEGAN) {
       this.moveToState(State.ACTIVE)

package/harmony/gesture_handler/src/main/ets/{GestureHandlerArkUIAdapter.ets → GestureHandlerArkUIAdapter.ts}

@@ -1,8 +1,9 @@
-import { Point } from "rnoh"
+import { Point } from "@rnoh/react-native-openharmony/ts"
 import { GestureHandler } from "./GestureHandler"
 import { AdaptedEvent, EventType, PointerType, TouchEventType, Touch } from "./Event"
 import { View } from "./View"
 import { RNGHLogger } from "./RNGHLogger"
+import { TouchEvent, TouchType, TouchObject } from "./types"
 
 export class GestureHandlerArkUIAdapter {
   private activePointerIds = new Set<number>()

package/harmony/gesture_handler/src/main/ets/GestureHandlerPackage.ts

@@ -1,5 +1,5 @@
-import {RNPackage, TurboModuleContext, TurboModulesFactory} from 'rnoh/ts';
-import type {TurboModule} from 'rnoh/ts';
+import {RNPackage, TurboModuleContext, TurboModulesFactory} from '@rnoh/react-native-openharmony/ts';
+import type {TurboModule} from '@rnoh/react-native-openharmony/ts';
 import {RNGestureHandlerModule} from './RNGestureHandlerModule';
 
 class GestureHandlerTurboModulesFactory extends TurboModulesFactory {

package/harmony/gesture_handler/src/main/ets/OutgoingEvent.ts

@@ -17,17 +17,17 @@ export type GestureUpdateEvent<GestureEventPayloadT = Record<string, unknown>> =
 export type GestureStateChangeEvent<GestureStateChangeEventPayloadT = Record<string, unknown>> = HandlerStateChangeEventPayload & GestureStateChangeEventPayloadT
 
 export type TouchData = {
-  absoluteX: number;
-  absoluteY: number;
+  id: number;
   x: number;
   y: number;
-  id: number;
+  absoluteX: number;
+  absoluteY: number;
 };
 
 export type GestureTouchEvent = {
-  state: State;
-  numberOfTouches: number;
   handlerTag: number;
+  numberOfTouches: number;
+  state: State;
   eventType: TouchEventType;
   allTouches: TouchData[];
   changedTouches: TouchData[];

package/harmony/gesture_handler/src/main/ets/RNGHLogger.ts

@@ -1,19 +1,31 @@
-import { RNOHContext } from "rnoh/ts"
+import { RNOHContext } from "@rnoh/react-native-openharmony/ts"
 
 export interface RNGHLogger {
   info(msg: string): void
 
   cloneWithPrefix(prefix: string): RNGHLogger
+
+  debug(msg: string)
+
+  error(msg: string)
 }
 
 export class StandardRNGHLogger implements RNGHLogger {
   constructor(private rnohLogger: RNOHContext["logger"], private prefix: string) {
   }
 
+  error(msg: string) {
+    this.rnohLogger.error(`${this.prefix}::${msg}`)
+  }
+
   info(msg: string) {
     this.rnohLogger.info(`${this.prefix}::${msg}`)
   }
 
+  debug(msg: string) {
+    this.rnohLogger.debug(`${this.prefix}::${msg}`)
+  }
+
   cloneWithPrefix(prefix: string) {
     return new StandardRNGHLogger(this.rnohLogger, `${this.prefix}::${prefix}`)
   }
@@ -23,6 +35,13 @@ export class FakeRNGHLogger implements RNGHLogger {
   info(msg: string) {
   }
 
+  debug(msg: string) {
+
+  }
+
+  error(msg: string): void {
+  }
+
   cloneWithPrefix(prefix: string) {
     return new FakeRNGHLogger()
   }

package/harmony/gesture_handler/src/main/ets/{RNGHRootTouchHandler.ets → RNGHRootTouchHandlerArkTS.ts}

@@ -1,11 +1,12 @@
-import { Tag } from "rnoh"
+import { Tag } from "@rnoh/react-native-openharmony/ts"
 import { GestureHandlerRegistry } from "./GestureHandlerRegistry"
 import { GestureHandlerArkUIAdapter } from "./GestureHandlerArkUIAdapter"
 import { ViewRegistry } from "./ViewRegistry"
 import { RNGHLogger } from './RNGHLogger'
+import { TouchEvent, TouchType } from "./types"
 
 
-export class RNGHRootTouchHandler {
+export class RNGHRootTouchHandlerArkTS {
   private adapterByViewTag: Map<number, GestureHandlerArkUIAdapter> = new Map() // TODO: remove an adapter when a view or gesture handler is removed
   private activeViewTags: number[] = []
   private viewRegistry: ViewRegistry
@@ -20,7 +21,8 @@ export class RNGHRootTouchHandler {
     this.logger = logger
   }
 
-  public handleTouch(e: TouchEvent) {
+  public handleTouch(touchEvent: any) {
+    const e = touchEvent as TouchEvent
     if (e.type === TouchType.Down) {
       this.activeViewTags = []
     }

package/harmony/gesture_handler/src/main/ets/RNGHRootTouchHandlerCAPI.ts

@@ -0,0 +1,87 @@
+import { RNGHRootTouchHandlerArkTS } from "./RNGHRootTouchHandlerArkTS"
+import { TouchEvent as TouchEventArkTS, TouchType, TouchObject } from "./types"
+import { RNGHLogger } from "./RNGHLogger"
+
+type RawTouchPoint = {
+  contactAreaHeight: number
+  contactAreaWidth: number
+  id: number
+  nodeX: number
+  nodeY: number
+  pressedTime: number
+  pressure: number
+  rawX: number
+  rawY: number
+  screenX: number
+  screenY: number
+  tiltX: number
+  tiltY: number
+  toolHeight: number
+  toolType: number
+  toolWidth: number
+  toolX: number
+  toolY: number
+  windowX: number
+  windowY: number
+}
+
+export type RawTouchEvent = {
+  action: number,
+  actionTouch: RawTouchPoint,
+  touchPoints: RawTouchPoint[],
+  sourceType: number,
+  timestamp: number
+}
+
+class TouchEvent {
+  constructor(private raw: RawTouchEvent) {
+  }
+
+  asTouchEventArkTS(): TouchEventArkTS {
+    const touchType = this.touchTypeFromAction(this.raw.action)
+    return {
+      type: this.touchTypeFromAction(this.raw.action),
+      touches: this.raw.touchPoints.map(tp => this.touchObjectFromTouchPoint(tp, touchType)),
+      changedTouches: [this.touchObjectFromTouchPoint(this.raw.actionTouch, touchType)],
+      timestamp: this.raw.timestamp
+    }
+  }
+
+  private touchTypeFromAction(action: number): TouchType {
+    switch (action) {
+      case 1:
+        return TouchType.Down
+      case 2:
+        return TouchType.Move
+      case 3:
+        return TouchType.Up
+      default:
+        return TouchType.Cancel
+    }
+  }
+
+  private touchObjectFromTouchPoint(touchPoint: RawTouchPoint, touchType: TouchType): TouchObject {
+    return {
+      id: touchPoint.id,
+      windowX: touchPoint.windowX,
+      windowY: touchPoint.windowY,
+      x: touchPoint.windowX,
+      y: touchPoint.windowY,
+      type: touchType
+    }
+  }
+}
+
+export class RNGHRootTouchHandlerCAPI {
+  private logger: RNGHLogger
+
+  constructor(logger: RNGHLogger, private touchHandlerArkTS: RNGHRootTouchHandlerArkTS) {
+    this.logger = logger.cloneWithPrefix("RNGHRootTouchHandlerCAPI")
+  }
+
+  handleTouch(rawTouchEvent: RawTouchEvent) {
+    this.logger.cloneWithPrefix("handleTouch").debug(JSON.stringify(rawTouchEvent))
+    this.touchHandlerArkTS.handleTouch(new TouchEvent(rawTouchEvent).asTouchEventArkTS())
+  }
+}
+

package/harmony/gesture_handler/src/main/ets/RNGestureHandlerButton.ets

@@ -1,10 +1,11 @@
-import { Descriptor, RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "rnoh"
+import { RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "@rnoh/react-native-openharmony"
+import { RNGestureHandlerButton as RNC } from "./namespace/RNGestureHandlerButton"
 
-export type RNGestureHandlerButtonDescriptor = Descriptor<"RNGestureHandlerButton">
+export type RNGestureHandlerButtonDescriptor = RNC.Descriptor
 
 @Component
 export struct RNGestureHandlerButton {
-  static readonly DESCRIPTOR_TYPE = "RNGestureHandlerButton"
+  static readonly NAME = RNC.NAME
   public ctx!: RNOHContext
   public tag: number = -1
   @BuilderParam public buildCustomComponent: (componentBuilderContext: ComponentBuilderContext) => void

package/harmony/gesture_handler/src/main/ets/RNGestureHandlerModule.ts

@@ -1,10 +1,19 @@
-import { TurboModule, TurboModuleContext } from 'rnoh/ts';
+import { TurboModule, TurboModuleContext, Tag } from '@rnoh/react-native-openharmony/ts';
+// import { TM } from "rnoh/generated/ts"
 import { GestureHandlerRegistry } from './GestureHandlerRegistry';
 import { GestureHandlerFactory } from "./GestureHandlerFactory"
 import { ViewRegistry } from './ViewRegistry';
 import { RNGHLogger, StandardRNGHLogger, FakeRNGHLogger } from './RNGHLogger';
-import { EventDispatcher, JSEventDispatcher, AnimatedEventDispatcher } from './EventDispatcher'
-import { RNOHScrollLocker } from "./RNOHScrollLocker"
+import {
+  EventDispatcher,
+  JSEventDispatcher,
+  AnimatedEventDispatcher,
+  ReanimatedEventDispatcher
+} from './EventDispatcher'
+import { RNOHScrollLockerArkTS, RNOHScrollLockerCAPI } from "./RNOHScrollLocker"
+import { State } from './State';
+import { RNGHRootTouchHandlerCAPI, RawTouchEvent } from "./RNGHRootTouchHandlerCAPI"
+import { RNGHRootTouchHandlerArkTS } from './RNGHRootTouchHandlerArkTS';
 
 export enum ActionType {
   REANIMATED_WORKLET = 1,
@@ -15,22 +24,48 @@ export enum ActionType {
 
 
 export class RNGestureHandlerModule extends TurboModule {
+// implements TM.RNGestureHandlerModule.Spec {
   static NAME = "RNGestureHandlerModule"
 
   private gestureHandlerRegistry = new GestureHandlerRegistry()
   private gestureHandlerFactory: GestureHandlerFactory | undefined = undefined
   private viewRegistry: ViewRegistry | undefined = undefined
   private logger: RNGHLogger
+  private touchHandlerByRootTag = new Map<Tag, RNGHRootTouchHandlerCAPI>()
 
   constructor(ctx: TurboModuleContext) {
     super(ctx)
     const debug = false
     this.logger = debug ? new StandardRNGHLogger(ctx.logger, "RNGH") : new FakeRNGHLogger()
+    if (this.ctx.rnInstance.getArchitecture() === "C_API") {
+      this.ctx.rnInstance.cppEventEmitter.subscribe("RNGH::TOUCH_EVENT", (e: any) => {
+        this.onTouch(e)
+      })
+      this.ctx.rnInstance.cppEventEmitter.subscribe("RNGH::ROOT_CREATED", (rootTag: any) => {
+        this.onGHRootCreated(rootTag)
+      })
+    }
+  }
+
+  private onGHRootCreated(rootTag: Tag) {
+    this.touchHandlerByRootTag.set(rootTag, new RNGHRootTouchHandlerCAPI(this.logger, new RNGHRootTouchHandlerArkTS(rootTag, this.viewRegistry, this.gestureHandlerRegistry, this.logger)));
+  }
+
+  private onTouch(e: RawTouchEvent & { rootTag: Tag }) {
+    const touchHandler = this.touchHandlerByRootTag.get(e.rootTag)
+    if (touchHandler) {
+      touchHandler.handleTouch(e);
+    } else {
+      this.logger.info(`Couldn't find touch handler for root tag: ${e.rootTag}`)
+    }
+
   }
 
   public install() {
     this.viewRegistry = new ViewRegistry(this.ctx.descriptorRegistry, this.ctx.componentManagerRegistry)
-    this.gestureHandlerFactory = new GestureHandlerFactory(this.logger, new RNOHScrollLocker(this.ctx.rnInstance))
+    const scrollLocker = this.ctx.rnInstance.getArchitecture() === "ARK_TS" ? new RNOHScrollLockerArkTS(this.ctx.rnInstance) : new RNOHScrollLockerCAPI(this.ctx.rnInstance);
+    this.gestureHandlerFactory = new GestureHandlerFactory(this.logger, scrollLocker)
+    return true
   }
 
   public createGestureHandler(
@@ -71,15 +106,13 @@ export class RNGestureHandlerModule extends TurboModule {
   private createEventDispatcher(actionType: ActionType, viewTag: number): EventDispatcher | null {
     switch (actionType) {
       case ActionType.REANIMATED_WORKLET:
-        this.ctx.logger.error("RNGH: Reanimated Worklets are not supported")
-        break;
+        return new ReanimatedEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('ReanimatedEventDispatcher'), viewTag)
       case ActionType.NATIVE_ANIMATED_EVENT:
         return new AnimatedEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('AnimatedEventDispatcher'), viewTag)
       case ActionType.JS_FUNCTION_OLD_API:
       case ActionType.JS_FUNCTION_NEW_API:
         return new JSEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('JSEventDispatcher'));
     }
-    return null
   }
 
   public updateGestureHandler(
@@ -120,6 +153,31 @@ export class RNGestureHandlerModule extends TurboModule {
   }
 
   public getViewRegistry() {
+    if (!this.viewRegistry) {
+      this.logger.info("Tried to get viewRegistry before it was initialized")
+      throw new Error("Tried to get viewRegistry before it was initialized")
+    }
     return this.viewRegistry
   }
+
+  public setGestureHandlerState(handlerTag: number, newState: State) {
+    const handler = this.getGestureHandlerRegistry().getGestureHandlerByHandlerTag(handlerTag);
+    switch (newState) {
+      case State.ACTIVE:
+        handler.activate();
+        break;
+      case State.BEGAN:
+        handler.begin();
+        break;
+      case State.END:
+        handler.end();
+        break;
+      case State.FAILED:
+        handler.fail();
+        break;
+      case State.CANCELLED:
+        handler.cancel();
+        break;
+    }
+  }
 }

package/harmony/gesture_handler/src/main/ets/RNGestureHandlerRootView.ets

@@ -1,18 +1,14 @@
-import { Descriptor, RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "rnoh"
-import { RNGHRootTouchHandler } from "./RNGHRootTouchHandler"
+import { RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "@rnoh/react-native-openharmony"
+import { RNGestureHandlerRootView as RNC } from "./namespace/RNGestureHandlerRootView"
+import { RNGHRootTouchHandlerArkTS as RNGHRootTouchHandler } from "./RNGHRootTouchHandlerArkTS"
 import { RNGestureHandlerModule } from "./RNGestureHandlerModule"
-import { Vector2D } from "./Vector2D"
-import { ViewRegistry } from './ViewRegistry'
 
-export type RNGestureHandlerRootViewDescriptor = Descriptor<"RNGestureHandlerRootView">
+
+export type RNGestureHandlerRootViewDescriptor = RNC.Descriptor
 
 @Component
 export struct RNGestureHandlerRootView {
-  /**
-   * @deprecated: Use RNGestureHandlerRootView.NAME instead
-   */
-  static readonly DESCRIPTOR_TYPE = "RNGestureHandlerRootView"
-  static readonly NAME = "RNGestureHandlerRootView"
+  static readonly NAME = RNC.NAME
   ctx!: RNOHContext
   tag: number = -1
   @BuilderParam buildCustomComponent: (componentBuilderContext: ComponentBuilderContext) => void
@@ -23,7 +19,7 @@ export struct RNGestureHandlerRootView {
   aboutToAppear() {
     const rnGestureHandlerModule = this.ctx.rnInstance.getTurboModule<RNGestureHandlerModule>(RNGestureHandlerModule.NAME)
     const rootTag = this.ctx.descriptorRegistry.getDescriptorLineage(this.tag)[0].tag
-    this.touchHandler = new RNGHRootTouchHandler(rootTag, rnGestureHandlerModule.getViewRegistry() as ViewRegistry, rnGestureHandlerModule.getGestureHandlerRegistry(), rnGestureHandlerModule.getLogger())
+    this.touchHandler = new RNGHRootTouchHandler(rootTag, rnGestureHandlerModule.getViewRegistry(), rnGestureHandlerModule.getGestureHandlerRegistry(), rnGestureHandlerModule.getLogger())
     this.handleDescriptorChange(this.ctx.descriptorRegistry.getDescriptor<RNGestureHandlerRootViewDescriptor>(this.tag))
     this.unsubscribes.push(this.ctx.descriptorRegistry.subscribeToDescriptorChanges(this.tag, (d) => {
       this.handleDescriptorChange(d as RNGestureHandlerRootViewDescriptor)

package/harmony/gesture_handler/src/main/ets/RNOHScrollLocker.ts

@@ -1,11 +1,23 @@
-import { RNInstance } from "rnoh/ts"
+import { RNInstance } from "@rnoh/react-native-openharmony/ts"
 import { ScrollLocker } from "./GestureHandler"
 
-export class RNOHScrollLocker implements ScrollLocker {
-  public constructor(private rnInstance: RNInstance) {
+export class RNOHScrollLockerArkTS implements ScrollLocker {
+  constructor(private rnInstance: RNInstance) {
   }
 
-  public lockScrollContainingViewTag(viewTag: number) {
+  lockScrollContainingViewTag(viewTag: number) {
     return this.rnInstance.blockComponentsGestures(viewTag)
   }
-}
+}
+
+export class RNOHScrollLockerCAPI implements ScrollLocker {
+  constructor(private rnInstance: RNInstance) {
+  }
+
+  lockScrollContainingViewTag(viewTag: number) {
+    this.rnInstance.postMessageToCpp("RNGH::SET_NATIVE_RESPONDERS_BLOCK", { targetTag: viewTag, shouldBlock: true });
+    return () => {
+      this.rnInstance.postMessageToCpp("RNGH::SET_NATIVE_RESPONDERS_BLOCK", { targetTag: viewTag, shouldBlock: false });
+    }
+  }
+}

package/harmony/gesture_handler/src/main/ets/View.ts

@@ -1,4 +1,4 @@
-import { DescriptorRegistry, Descriptor, Tag } from "rnoh/ts"
+import { DescriptorRegistry, Descriptor, Tag } from "@rnoh/react-native-openharmony/ts"
 import { Vector2D } from "./Vector2D"
 
 export type BoundingBox = {

package/harmony/gesture_handler/src/main/ets/ViewRegistry.ts

@@ -1,4 +1,4 @@
-import { DescriptorRegistry, ComponentManagerRegistry, Tag } from "rnoh/ts"
+import { DescriptorRegistry, ComponentManagerRegistry, Tag } from "@rnoh/react-native-openharmony/ts"
 import { View } from "./View"
 
 export class ViewRegistry {

package/harmony/gesture_handler/src/main/ets/namespace/RNGestureHandlerButton.ts

@@ -0,0 +1,140 @@
+// This file was generated.
+import {
+  Descriptor as ComponentDescriptor,
+  ViewBaseProps,
+  ViewRawProps,
+  ViewDescriptorWrapperBase,
+  ColorValue,
+  Color,
+  RNInstance,
+  Tag,
+  RNComponentCommandReceiver,
+  ViewPropsSelector,
+} from '@rnoh/react-native-openharmony/ts';
+
+
+export namespace RNGestureHandlerButton {
+  export const NAME = "RNGestureHandlerButton" as const
+
+  export interface DirectRawProps {
+    exclusive?: boolean;
+    foreground?: boolean;
+    borderless?: boolean;
+    enabled?: boolean;
+    rippleColor?: ColorValue;
+    rippleRadius?: number;
+    touchSoundDisabled?: boolean;
+  }
+  
+  export interface Props extends ViewBaseProps {}
+  
+  export interface State {}
+  
+  export interface RawProps extends ViewRawProps, DirectRawProps {}
+  
+  export class PropsSelector extends ViewPropsSelector<Props, RawProps> {
+    get exclusive() {
+      return this.rawProps.exclusive ?? true;
+    }
+    
+    get foreground() {
+      return this.rawProps.foreground ?? false;
+    }
+    
+    get borderless() {
+      return this.rawProps.borderless ?? false;
+    }
+    
+    get enabled() {
+      return this.rawProps.enabled ?? true;
+    }
+    
+    get rippleRadius() {
+      return this.rawProps.rippleRadius ?? 0;
+    }
+    
+    get touchSoundDisabled() {
+      return this.rawProps.touchSoundDisabled ?? false;
+    }
+    
+  
+    get rippleColor() {
+        if (this.rawProps.rippleColor) {
+          return Color.fromColorValue(this.rawProps.rippleColor)
+        } else {
+          return new Color({ r: 0, g: 0, b: 0, a: 255})
+        }
+    }
+    
+  }
+
+  export type Descriptor = ComponentDescriptor<
+    typeof NAME,
+    Props,
+    State,
+    RawProps
+  >;
+  
+  export class DescriptorWrapper extends ViewDescriptorWrapperBase<
+    typeof NAME,
+    Props,
+    State,
+    RawProps,
+    PropsSelector
+  > {
+    protected createPropsSelector() {
+      return new PropsSelector(this.descriptor.props, this.descriptor.rawProps)
+    }
+  }
+  
+  export interface EventPayloadByName {
+  }
+  
+  export class EventEmitter {
+    constructor(private rnInstance: RNInstance, private tag: Tag) {}
+    
+    emit<TEventName extends keyof EventPayloadByName>(eventName: TEventName, payload: EventPayloadByName[TEventName]) {
+      this.rnInstance.emitComponentEvent(this.tag, eventName, payload)
+    }
+  }
+  
+  export interface CommandArgvByName {
+  }
+  
+  export class CommandReceiver {
+    private listenersByCommandName = new Map<string, Set<(...args: any[]) => void>>()
+    private cleanUp: (() => void) | undefined = undefined
+  
+    constructor(private componentCommandReceiver: RNComponentCommandReceiver, private tag: Tag) {
+    }
+  
+    subscribe<TCommandName extends keyof CommandArgvByName>(commandName: TCommandName, listener: (argv: CommandArgvByName[TCommandName]) => void) {
+      if (!this.listenersByCommandName.has(commandName)) {
+        this.listenersByCommandName.set(commandName, new Set())
+      }
+      this.listenersByCommandName.get(commandName)!.add(listener)
+      const hasRegisteredCommandReceiver = !!this.cleanUp
+      if (!hasRegisteredCommandReceiver) {
+        this.cleanUp = this.componentCommandReceiver.registerCommandCallback(this.tag, (commandName: string, argv: any[]) => {
+          if (this.listenersByCommandName.has(commandName)) {
+            const listeners = this.listenersByCommandName.get(commandName)!
+            listeners.forEach(listener => {
+              listener(argv)
+            })
+          }
+        })
+      }
+  
+      return () => {
+        this.listenersByCommandName.get(commandName)?.delete(listener)
+        if (this.listenersByCommandName.get(commandName)?.size ?? 0 === 0) {
+          this.listenersByCommandName.delete(commandName)
+        }
+        if (this.listenersByCommandName.size === 0) {
+          this.cleanUp?.()
+        }
+      }
+    }
+  }
+
+}

package/harmony/gesture_handler/src/main/ets/namespace/RNGestureHandlerModule.ts

@@ -0,0 +1,25 @@
+// This file was generated.
+import { Tag } from "../../ts"
+
+export namespace RNGestureHandlerModule {
+  export const NAME = 'RNGestureHandlerModule' as const
+
+  export interface Spec {
+    handleSetJSResponder(tag: number, blockNativeResponder: boolean): void;
+  
+    handleClearJSResponder(): void;
+  
+    createGestureHandler(handlerName: string, handlerTag: number, config: Object): void;
+  
+    attachGestureHandler(handlerTag: number, newView: number, actionType: number): void;
+  
+    updateGestureHandler(handlerTag: number, newConfig: Object): void;
+  
+    dropGestureHandler(handlerTag: number): void;
+  
+    install(): boolean;
+  
+    flushOperations(): void;
+  
+  }
+}