react-native-gesture-handler 2.19.0 → 2.20.1

package/android/build.gradle

@@ -33,16 +33,10 @@ def resolveReactNativeDirectory() {
         return file(reactNativeLocation)
     }
 
-    // monorepo workaround
-    // react-native can be hoisted or in project's own node_modules
-    def reactNativeFromProjectNodeModules = file("${rootProject.projectDir}/../node_modules/react-native")
-    if (reactNativeFromProjectNodeModules.exists()) {
-        return reactNativeFromProjectNodeModules
-    }
-
-    def reactNativeFromNodeModulesWithReanimated = file("${projectDir}/../../react-native")
-    if (reactNativeFromNodeModulesWithReanimated.exists()) {
-        return reactNativeFromNodeModulesWithReanimated
+    // Fallback to node resolver for custom directory structures like monorepos.
+    def reactNativePackage = file(["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim())
+    if (reactNativePackage.exists()) {
+        return reactNativePackage.parentFile
     }
 
     throw new Exception(
@@ -124,8 +118,7 @@ android {
             externalNativeBuild {
                 cmake {
                     cppFlags "-O2", "-frtti", "-fexceptions", "-Wall", "-Werror", "-std=c++20", "-DANDROID"
-                    arguments "-DAPP_BUILD_DIR=${appProject.buildDir}",
-                        "-DREACT_NATIVE_DIR=${REACT_NATIVE_DIR}",
+                    arguments "-DREACT_NATIVE_DIR=${REACT_NATIVE_DIR}",
                         "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
                         "-DANDROID_STL=c++_shared"
                     abiFilters (*reactNativeArchitectures())
@@ -153,6 +146,8 @@ android {
         // only the ones that make the build fail (ideally we should only include libgesturehandler but we
         // are only allowed to specify exclude patterns)
         exclude "**/libreact_render*.so"
+        exclude "**/libreactnative.so"
+        exclude "**/libjsi.so"
     }
 
     sourceSets.main {

package/android/paper/src/main/java/com/swmansion/gesturehandler/ReactContextExtensions.kt

@@ -6,7 +6,7 @@ import com.facebook.react.uimanager.events.Event
 
 fun ReactContext.dispatchEvent(event: Event<*>) {
   try {
-    this.getNativeModule(UIManagerModule::class.java)!!.eventDispatcher.dispatchEvent(event)
+    this.getNativeModule(UIManagerModule::class.java)!!.getEventDispatcher().dispatchEvent(event)
   } catch (e: NullPointerException) {
     throw Exception("Couldn't get an instance of UIManagerModule. Gesture Handler is unable to send an event.", e)
   }

package/android/src/main/java/com/swmansion/gesturehandler/core/GestureUtils.kt

@@ -45,6 +45,7 @@ object GestureUtils {
       event.getY(lastPointerIdx)
     }
   }
+
   fun coneToDeviation(angle: Double): Double =
     cos(Math.toRadians(angle / 2.0))
 }

package/android/src/main/java/com/swmansion/gesturehandler/core/HoverGestureHandler.kt

@@ -11,6 +11,8 @@ import com.swmansion.gesturehandler.react.RNViewConfigurationHelper
 class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
   private var handler: Handler? = null
   private var finishRunnable = Runnable { finish() }
+  var stylusData: StylusData = StylusData()
+    private set
 
   private infix fun isAncestorOf(other: GestureHandler<*>): Boolean {
     var current: View? = other.view
@@ -103,6 +105,10 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
         finish()
       }
 
+      this.state == STATE_ACTIVE && event.getToolType(0) == MotionEvent.TOOL_TYPE_STYLUS -> {
+        stylusData = StylusData.fromEvent(event)
+      }
+
       this.state == STATE_UNDETERMINED &&
         (event.action == MotionEvent.ACTION_HOVER_MOVE || event.action == MotionEvent.ACTION_HOVER_ENTER) -> {
         begin()
@@ -111,6 +117,11 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     }
   }
 
+  override fun onReset() {
+    super.onReset()
+    stylusData = StylusData()
+  }
+
   private fun finish() {
     when (this.state) {
       STATE_UNDETERMINED -> cancel()

package/android/src/main/java/com/swmansion/gesturehandler/core/PanGestureHandler.kt

@@ -45,6 +45,8 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   private var activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
   private val activateDelayed = Runnable { activate() }
   private var handler: Handler? = null
+  var stylusData: StylusData = StylusData()
+    private set
 
   /**
    * On Android when there are multiple pointers on the screen pan gestures most often just consider
@@ -212,6 +214,10 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       return
     }
 
+    if (event.getToolType(0) == MotionEvent.TOOL_TYPE_STYLUS) {
+      stylusData = StylusData.fromEvent(event)
+    }
+
     val state = state
     val action = sourceEvent.actionMasked
     if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
@@ -295,6 +301,8 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       it.recycle()
       velocityTracker = null
     }
+
+    stylusData = StylusData()
   }
 
   override fun resetProgress() {

package/android/src/main/java/com/swmansion/gesturehandler/core/StylusData.kt

@@ -0,0 +1,103 @@
+package com.swmansion.gesturehandler.core
+
+import android.view.MotionEvent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import kotlin.math.PI
+import kotlin.math.abs
+import kotlin.math.atan
+import kotlin.math.cos
+import kotlin.math.round
+import kotlin.math.sin
+import kotlin.math.tan
+
+data class StylusData(
+  val tiltX: Double = 0.0,
+  val tiltY: Double = 0.0,
+  val altitudeAngle: Double = 0.0,
+  val azimuthAngle: Double = 0.0,
+  val pressure: Double = -1.0
+) {
+  fun toReadableMap(): ReadableMap {
+    val stylusDataObject = Arguments.createMap().apply {
+      putDouble("tiltX", tiltX)
+      putDouble("tiltY", tiltY)
+      putDouble("altitudeAngle", altitudeAngle)
+      putDouble("azimuthAngle", azimuthAngle)
+      putDouble("pressure", pressure)
+    }
+
+    val readableStylusData: ReadableMap = stylusDataObject
+
+    return readableStylusData
+  }
+
+  companion object {
+    // Source: https://w3c.github.io/pointerevents/#converting-between-tiltx-tilty-and-altitudeangle-azimuthangle
+    private fun spherical2tilt(altitudeAngle: Double, azimuthAngle: Double): Pair<Double, Double> {
+      val eps = 0.000000001
+      val radToDeg = 180 / PI
+
+      var tiltXrad = 0.0
+      var tiltYrad = 0.0
+
+      if (altitudeAngle < eps) {
+        // the pen is in the X-Y plane
+        if (azimuthAngle < eps || abs(azimuthAngle - 2 * PI) < eps) {
+          // pen is on positive X axis
+          tiltXrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI / 2) < eps) {
+          // pen is on positive Y axis
+          tiltYrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI) < eps) {
+          // pen is on negative X axis
+          tiltXrad = -PI / 2
+        }
+        if (abs(azimuthAngle - (3 * PI) / 2) < eps) {
+          // pen is on negative Y axis
+          tiltYrad = -PI / 2
+        }
+        if (azimuthAngle > eps && abs(azimuthAngle - PI / 2) < eps) {
+          tiltXrad = PI / 2
+          tiltYrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI / 2) > eps && abs(azimuthAngle - PI) < eps) {
+          tiltXrad = -PI / 2
+          tiltYrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI) > eps && abs(azimuthAngle - (3 * PI) / 2) < eps) {
+          tiltXrad = -PI / 2
+          tiltYrad = -PI / 2
+        }
+        if (abs(azimuthAngle - (3 * PI) / 2) > eps && abs(azimuthAngle - 2 * PI) < eps) {
+          tiltXrad = PI / 2
+          tiltYrad = -PI / 2
+        }
+      } else {
+        val tanAlt = tan(altitudeAngle)
+
+        tiltXrad = atan(cos(azimuthAngle) / tanAlt)
+        tiltYrad = atan(sin(azimuthAngle) / tanAlt)
+      }
+
+      val tiltX = round(tiltXrad * radToDeg)
+      val tiltY = round(tiltYrad * radToDeg)
+
+      return Pair(tiltX, tiltY)
+    }
+
+    fun fromEvent(event: MotionEvent): StylusData {
+      // On web and iOS 0 degrees means that stylus is parallel to the surface. On android this value will be PI / 2.
+      val altitudeAngle = (PI / 2) - event.getAxisValue(MotionEvent.AXIS_TILT).toDouble()
+      val pressure = event.getPressure(0).toDouble()
+      val orientation = event.getOrientation(0).toDouble()
+      // To get azimuth angle, we need to use orientation property (https://developer.android.com/develop/ui/compose/touch-input/stylus-input/advanced-stylus-features#orientation).
+      val azimuthAngle = (orientation + PI / 2).mod(2 * PI)
+      val tilts = spherical2tilt(altitudeAngle, azimuthAngle)
+
+      return StylusData(tilts.first, tilts.second, altitudeAngle, azimuthAngle, pressure)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerButtonViewManager.kt

@@ -286,22 +286,11 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       return false
     }
 
-    private fun updateBackgroundColor(backgroundColor: Int, selectable: Drawable?) {
+    private fun updateBackgroundColor(backgroundColor: Int, borderDrawable: Drawable, selectable: Drawable?) {
       val colorDrawable = PaintDrawable(backgroundColor)
-      val borderDrawable = PaintDrawable(Color.TRANSPARENT)
 
       if (hasBorderRadii) {
         colorDrawable.setCornerRadii(buildBorderRadii())
-        borderDrawable.setCornerRadii(buildBorderRadii())
-      }
-
-      if (borderWidth > 0f) {
-        borderDrawable.paint.apply {
-          style = Paint.Style.STROKE
-          strokeWidth = borderWidth
-          color = borderColor ?: Color.BLACK
-          pathEffect = buildBorderStyle()
-        }
       }
 
       val layerDrawable = LayerDrawable(if (selectable != null) arrayOf(colorDrawable, selectable, borderDrawable) else arrayOf(colorDrawable, borderDrawable))
@@ -324,6 +313,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       }
 
       val selectable = createSelectableDrawable()
+      val borderDrawable = createBorderDrawable()
 
       if (hasBorderRadii && selectable is RippleDrawable) {
         val mask = PaintDrawable(Color.WHITE)
@@ -334,13 +324,32 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       if (useDrawableOnForeground && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
         foreground = selectable
         if (_backgroundColor != Color.TRANSPARENT) {
-          updateBackgroundColor(_backgroundColor, null)
+          updateBackgroundColor(_backgroundColor, borderDrawable, null)
         }
       } else if (_backgroundColor == Color.TRANSPARENT && rippleColor == null) {
-        background = selectable
+        background = LayerDrawable(arrayOf(selectable, borderDrawable))
       } else {
-        updateBackgroundColor(_backgroundColor, selectable)
+        updateBackgroundColor(_backgroundColor, borderDrawable, selectable)
+      }
+    }
+
+    private fun createBorderDrawable(): Drawable {
+      val borderDrawable = PaintDrawable(Color.TRANSPARENT)
+
+      if (hasBorderRadii) {
+        borderDrawable.setCornerRadii(buildBorderRadii())
+      }
+
+      if (borderWidth > 0f) {
+        borderDrawable.paint.apply {
+          style = Paint.Style.STROKE
+          strokeWidth = borderWidth
+          color = borderColor ?: Color.BLACK
+          pathEffect = buildBorderStyle()
+        }
       }
+
+      return borderDrawable
     }
 
     private fun createSelectableDrawable(): Drawable? {

package/android/src/main/java/com/swmansion/gesturehandler/react/eventbuilders/HoverGestureHandlerEventDataBuilder.kt

@@ -3,18 +3,21 @@ package com.swmansion.gesturehandler.react.eventbuilders
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.PixelUtil
 import com.swmansion.gesturehandler.core.HoverGestureHandler
+import com.swmansion.gesturehandler.core.StylusData
 
 class HoverGestureHandlerEventDataBuilder(handler: HoverGestureHandler) : GestureHandlerEventDataBuilder<HoverGestureHandler>(handler) {
   private val x: Float
   private val y: Float
   private val absoluteX: Float
   private val absoluteY: Float
+  private val stylusData: StylusData
 
   init {
     x = handler.lastRelativePositionX
     y = handler.lastRelativePositionY
     absoluteX = handler.lastPositionInWindowX
     absoluteY = handler.lastPositionInWindowY
+    stylusData = handler.stylusData
   }
 
   override fun buildEventData(eventData: WritableMap) {
@@ -25,6 +28,10 @@ class HoverGestureHandlerEventDataBuilder(handler: HoverGestureHandler) : Gestur
       putDouble("y", PixelUtil.toDIPFromPixel(y).toDouble())
       putDouble("absoluteX", PixelUtil.toDIPFromPixel(absoluteX).toDouble())
       putDouble("absoluteY", PixelUtil.toDIPFromPixel(absoluteY).toDouble())
+
+      if (stylusData.pressure != -1.0) {
+        putMap("stylusData", stylusData.toReadableMap())
+      }
     }
   }
 }

package/android/src/main/java/com/swmansion/gesturehandler/react/eventbuilders/PanGestureHandlerEventDataBuilder.kt

@@ -3,6 +3,7 @@ package com.swmansion.gesturehandler.react.eventbuilders
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.PixelUtil
 import com.swmansion.gesturehandler.core.PanGestureHandler
+import com.swmansion.gesturehandler.core.StylusData
 
 class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) : GestureHandlerEventDataBuilder<PanGestureHandler>(handler) {
   private val x: Float
@@ -13,6 +14,7 @@ class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) : GestureHan
   private val translationY: Float
   private val velocityX: Float
   private val velocityY: Float
+  private val stylusData: StylusData
 
   init {
     x = handler.lastRelativePositionX
@@ -23,6 +25,7 @@ class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) : GestureHan
     translationY = handler.translationY
     velocityX = handler.velocityX
     velocityY = handler.velocityY
+    stylusData = handler.stylusData
   }
 
   override fun buildEventData(eventData: WritableMap) {
@@ -37,6 +40,10 @@ class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) : GestureHan
       putDouble("translationY", PixelUtil.toDIPFromPixel(translationY).toDouble())
       putDouble("velocityX", PixelUtil.toDIPFromPixel(velocityX).toDouble())
       putDouble("velocityY", PixelUtil.toDIPFromPixel(velocityY).toDouble())
+
+      if (stylusData.pressure != -1.0) {
+        putMap("stylusData", stylusData.toReadableMap())
+      }
     }
   }
 }

package/android/src/main/jni/CMakeLists.txt

@@ -26,12 +26,21 @@ target_include_directories(
 )
 
 find_package(ReactAndroid REQUIRED CONFIG)
-
-target_link_libraries(
-  gesturehandler
-  ReactAndroid::react_render_core
-  ReactAndroid::react_render_uimanager
-  ReactAndroid::react_render_graphics
-  ReactAndroid::jsi
-  ReactAndroid::react_nativemodule_core
-)
+if (ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::reactnative
+    ReactAndroid::jsi
+  )
+elseif (ReactAndroid_VERSION_MINOR GREATER_EQUAL 75)
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::react_render_core
+    ReactAndroid::react_render_uimanager
+    ReactAndroid::react_render_graphics
+    ReactAndroid::jsi
+    ReactAndroid::react_nativemodule_core
+  )
+else ()
+  message(FATAL_ERROR "react-native-gesture-handler on the New Architecture requires react-native 0.75 or newer.")
+endif ()

package/apple/Handlers/RNLongPressHandler.m

@@ -233,10 +233,12 @@
     recognizer.allowableMovement = [RCTConvert CGFloat:prop];
   }
 
+#if !TARGET_OS_TV
   prop = config[@"numberOfPointers"];
   if (prop != nil) {
     recognizer.numberOfTouchesRequired = [RCTConvert CGFloat:prop];
   }
+#endif
 }
 
 #if !TARGET_OS_OSX

package/apple/Handlers/RNPanHandler.m

@@ -7,6 +7,7 @@
 //
 
 #import "RNPanHandler.h"
+#import "RNGHStylusData.h"
 
 #if TARGET_OS_OSX
 
@@ -31,6 +32,10 @@
 @property (nonatomic) CGFloat failOffsetYEnd;
 @property (nonatomic) CGFloat activateAfterLongPress;
 
+#if !TARGET_OS_OSX && !TARGET_OS_TV
+@property (atomic, readonly, strong) RNGHStylusData *stylusData;
+#endif
+
 - (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
 
 @end
@@ -80,6 +85,28 @@
 }
 #endif
 
+#if !TARGET_OS_OSX && !TARGET_OS_TV
+- (void)tryUpdateStylusData:(UIEvent *)event
+{
+  UITouch *touch = [[event allTouches] anyObject];
+
+  if (touch.type != UITouchTypePencil) {
+    return;
+  } else if (_stylusData == nil) {
+    _stylusData = [[RNGHStylusData alloc] init];
+  }
+
+  _stylusData.altitudeAngle = touch.altitudeAngle;
+  _stylusData.azimuthAngle = [touch azimuthAngleInView:nil];
+  _stylusData.pressure = touch.force / touch.maximumPossibleForce;
+
+  CGPoint tilts = ghSpherical2tilt(_stylusData.altitudeAngle, _stylusData.azimuthAngle);
+
+  _stylusData.tiltX = tilts.x;
+  _stylusData.tiltY = tilts.y;
+}
+#endif
+
 - (void)activateAfterLongPress
 {
   self.state = UIGestureRecognizerStateBegan;
@@ -102,6 +129,8 @@
   } else {
     super.minimumNumberOfTouches = _realMinimumNumberOfTouches;
   }
+
+  [self tryUpdateStylusData:event];
 #endif
 
 #if TARGET_OS_OSX
@@ -150,17 +179,28 @@
       [self setTranslation:CGPointMake(0, 0) inView:self.view];
     }
   }
+
+  [self tryUpdateStylusData:event];
 #endif
 }
 
 - (void)interactionsEnded:(NSSet *)touches withEvent:(UIEvent *)event
 {
   [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+
+#if !TARGET_OS_TV && !TARGET_OS_OSX
+  [self tryUpdateStylusData:event];
+#endif
 }
 
 - (void)interactionsCancelled:(NSSet *)touches withEvent:(UIEvent *)event
 {
   [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+
+#if !TARGET_OS_TV && !TARGET_OS_OSX
+  [self tryUpdateStylusData:event];
+#endif
+
   [self reset];
 }
 
@@ -224,6 +264,10 @@
   self.enabled = YES;
   [super reset];
   [_gestureHandler reset];
+
+#if !TARGET_OS_TV && !TARGET_OS_OSX
+  _stylusData = nil;
+#endif
 }
 
 - (void)updateHasCustomActivationCriteria
@@ -405,17 +449,23 @@
                                 withTranslation:[recognizer translationInView:recognizer.view.window.contentView]
                                    withVelocity:[recognizer velocityInView:recognizer.view.window.contentView]
                             withNumberOfTouches:1
-                                withPointerType:RNGestureHandlerMouse];
+                                withPointerType:RNGestureHandlerMouse
+                                 withStylusData:nil];
 }
 #else
 - (RNGestureHandlerEventExtraData *)eventExtraData:(UIPanGestureRecognizer *)recognizer
 {
-  return [RNGestureHandlerEventExtraData forPan:[recognizer locationInView:recognizer.view]
-                           withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
-                                withTranslation:[recognizer translationInView:recognizer.view.window]
-                                   withVelocity:[recognizer velocityInView:recognizer.view.window]
-                            withNumberOfTouches:recognizer.numberOfTouches
-                                withPointerType:_pointerType];
+  RNBetterPanGestureRecognizer *panRecognizer = (RNBetterPanGestureRecognizer *)recognizer;
+
+  return [RNGestureHandlerEventExtraData
+                    forPan:[recognizer locationInView:recognizer.view]
+      withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
+           withTranslation:[recognizer translationInView:recognizer.view.window]
+              withVelocity:[recognizer velocityInView:recognizer.view.window]
+       withNumberOfTouches:recognizer.numberOfTouches
+           withPointerType:_pointerType
+            withStylusData:[panRecognizer.stylusData toDictionary]]; // In Objective-C calling method on nil returns
+                                                                     // nil, therefore this line does not crash.
 }
 #endif
 

package/apple/Handlers/RNRotationHandler.m

@@ -149,7 +149,7 @@
 #if TARGET_OS_OSX
 - (RNGestureHandlerEventExtraData *)eventExtraData:(NSRotationGestureRecognizer *)recognizer
 {
-  return [RNGestureHandlerEventExtraData forRotation:recognizer.rotation
+  return [RNGestureHandlerEventExtraData forRotation:-recognizer.rotation
                                      withAnchorPoint:[recognizer locationInView:recognizer.view]
                                         withVelocity:((RNBetterRotationRecognizer *)recognizer).velocity
                                  withNumberOfTouches:2

package/apple/RNGHStylusData.h

@@ -0,0 +1,77 @@
+//
+//  RNGHStylusData.h
+//  Pods
+//
+//  Created by Michał Bert on 18/09/2024.
+//
+
+#ifndef RNGHStylusData_h
+#define RNGHStylusData_h
+
+@interface RNGHStylusData : NSObject
+
+@property (atomic, assign) double tiltX;
+@property (atomic, assign) double tiltY;
+@property (atomic, assign) double altitudeAngle;
+@property (atomic, assign) double azimuthAngle;
+@property (atomic, assign) double pressure;
+
+- (NSDictionary *)toDictionary;
+
+@end
+
+static CGPoint ghSpherical2tilt(double altitudeAngle, double azimuthAngle)
+{
+  CGPoint tilts = {.x = 0.0, .y = 0.0};
+
+  const double radToDeg = 180 / M_PI;
+  const double eps = 0.000000001;
+
+  if (altitudeAngle < eps) {
+    // the pen is in the X-Y plane
+    if (azimuthAngle < eps || fabs(azimuthAngle - 2 * M_PI) < eps) {
+      // pen is on positive X axis
+      tilts.x = M_PI_2;
+    }
+    if (fabs(azimuthAngle - M_PI_2) < eps) {
+      // pen is on positive Y axis
+      tilts.y = M_PI_2;
+    }
+    if (fabs(azimuthAngle - M_PI) < eps) {
+      // pen is on negative X axis
+      tilts.x = -M_PI_2;
+    }
+    if (fabs(azimuthAngle - 3 * M_PI_2) < eps) {
+      // pen is on negative Y axis
+      tilts.y = -M_PI_2;
+    }
+    if (azimuthAngle > eps && fabs(azimuthAngle - M_PI_2) < eps) {
+      tilts.x = M_PI_2;
+      tilts.y = M_PI_2;
+    }
+    if (fabs(azimuthAngle - M_PI_2) > eps && fabs(azimuthAngle - M_PI) < eps) {
+      tilts.x = -M_PI_2;
+      tilts.y = M_PI_2;
+    }
+    if (azimuthAngle - M_PI > eps && fabs(azimuthAngle - 3 * M_PI_2) < eps) {
+      tilts.x = -M_PI_2;
+      tilts.y = -M_PI_2;
+    }
+    if (fabs(azimuthAngle - 3 * M_PI_2) > eps && fabs(azimuthAngle - 2 * M_PI) < eps) {
+      tilts.x = M_PI_2;
+      tilts.y = -M_PI_2;
+    }
+  } else {
+    const double tanAlt = tan(altitudeAngle);
+
+    tilts.x = atan(cos(azimuthAngle) / tanAlt);
+    tilts.y = atan(sin(azimuthAngle) / tanAlt);
+  }
+
+  tilts.x = round(tilts.x * radToDeg);
+  tilts.y = round(tilts.y * radToDeg);
+
+  return tilts;
+}
+
+#endif /* RNGHStylusData_h */

package/apple/RNGHStylusData.m

@@ -0,0 +1,37 @@
+//
+//  RNGHStylusData.m
+//  DoubleConversion
+//
+//  Created by Michał Bert on 18/09/2024.
+//
+
+#import "RNGHStylusData.h"
+#import <Foundation/Foundation.h>
+
+@implementation RNGHStylusData
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    self.tiltX = 0;
+    self.tiltY = 0;
+    self.altitudeAngle = M_PI_2;
+    self.azimuthAngle = 0;
+    self.pressure = 0;
+  }
+
+  return self;
+}
+
+- (NSDictionary *)toDictionary
+{
+  return @{
+    @"tiltX" : @(_tiltX),
+    @"tiltY" : @(_tiltY),
+    @"altitudeAngle" : @(_altitudeAngle),
+    @"azimuthAngle" : @(_azimuthAngle),
+    @"pressure" : @(_pressure),
+  };
+}
+
+@end