react-native-swipeable-actions 0.1.0

package/ios/SwipePhysics.swift

@@ -0,0 +1,66 @@
+import Foundation
+#if canImport(CoreGraphics)
+import CoreGraphics
+#endif
+
+struct SwipePhysics {
+
+    static func applyRubberBand(
+        translation: CGFloat,
+        actionsWidth: CGFloat,
+        isLeading: Bool
+    ) -> CGFloat {
+        let divisor = SwipeAnimationConfig.rubberBandDivisor
+
+        if isLeading {
+            if translation > actionsWidth {
+                return actionsWidth + ((translation - actionsWidth) / divisor)
+            } else if translation < 0 {
+                return translation / divisor
+            }
+        } else {
+            if translation < -actionsWidth {
+                return -actionsWidth - ((abs(translation) - actionsWidth) / divisor)
+            } else if translation > 0 {
+                return translation / divisor
+            }
+        }
+        return translation
+    }
+
+    static func shouldSnapToOpen(
+        projectedTranslation: CGFloat,
+        actionsWidth: CGFloat,
+        threshold: CGFloat,
+        isLeading: Bool,
+        isCurrentlyOpen: Bool
+    ) -> Bool {
+        let thresholdDistance = actionsWidth * threshold
+
+        if isLeading {
+            return isCurrentlyOpen
+                ? projectedTranslation > -thresholdDistance
+                : projectedTranslation > thresholdDistance
+        } else {
+            return isCurrentlyOpen
+                ? projectedTranslation < thresholdDistance
+                : projectedTranslation < -thresholdDistance
+        }
+    }
+
+    static func projectFinalPosition(
+        translation: CGFloat,
+        velocity: CGFloat,
+        friction: CGFloat
+    ) -> CGFloat {
+        let factor = SwipeAnimationConfig.velocityProjectionFactor
+        return (translation * friction) + (velocity * friction * factor)
+    }
+
+    static func calculateSpringVelocity(from gestureVelocity: CGFloat) -> CGFloat {
+        guard abs(gestureVelocity) > 0 else { return 0 }
+        let normalizer = SwipeAnimationConfig.velocityNormalizer
+        let maxVelocity = SwipeAnimationConfig.maxNormalizedVelocity
+        return min(abs(gestureVelocity) / normalizer, maxVelocity)
+    }
+}

package/ios/SwipeableModule.swift

@@ -0,0 +1,84 @@
+import ExpoModulesCore
+
+public class SwipeableModule: Module {
+    public func definition() -> ModuleDefinition {
+        Name("Swipeable")
+
+        // Module-level functions (by recyclingKey)
+        Function("openByKey") { (key: String) in
+            SwipeableView.openByKey(key)
+        }
+
+        Function("closeByKey") { (key: String, animated: Bool?) in
+            SwipeableView.closeByKey(key, animated: animated ?? true)
+        }
+
+        Function("closeAll") { (animated: Bool?) in
+            SwipeableView.closeAll(animated: animated ?? true)
+        }
+
+        View(SwipeableView.self) {
+            // Props
+            Prop("actionsWidth") { (view: SwipeableView, width: CGFloat) in
+                view.actionsWidth = width
+            }
+
+            Prop("actionsPosition") { (view: SwipeableView, position: String) in
+                view.actionsPosition = position
+            }
+
+            Prop("friction") { (view: SwipeableView, friction: CGFloat) in
+                view.friction = friction
+            }
+
+            Prop("threshold") { (view: SwipeableView, threshold: CGFloat) in
+                view.threshold = threshold
+            }
+
+            Prop("dragOffsetFromEdge") { (view: SwipeableView, offset: CGFloat) in
+                view.dragOffsetFromEdge = offset
+            }
+
+            Prop("recyclingKey") { (view: SwipeableView, key: String?) in
+                view.recyclingKey = key
+            }
+
+            Prop("autoClose") { (view: SwipeableView, autoClose: Bool) in
+                view.autoClose = autoClose
+            }
+
+            Prop("autoCloseTimeout") { (view: SwipeableView, timeout: CGFloat) in
+                view.autoCloseTimeout = timeout
+            }
+
+            // Events
+            Events("onSwipeProgress", "onSwipeStart", "onSwipeStateChange", "onSwipeEnd")
+
+            // Imperative methods
+            AsyncFunction("close") { (view: SwipeableView, animated: Bool?) in
+                DispatchQueue.main.async {
+                    view.close(animated: animated ?? true)
+                }
+            }
+
+            AsyncFunction("open") { (view: SwipeableView) in
+                DispatchQueue.main.async {
+                    view.open()
+                }
+            }
+
+            // Gesture handling methods (called from JS gesture handler)
+            AsyncFunction("handleGestureStart") { (view: SwipeableView) in
+                view.handleGestureStart()
+            }
+
+            AsyncFunction("handleGestureUpdate") { (view: SwipeableView, translationX: CGFloat, velocityX: CGFloat) in
+                view.handleGestureUpdate(translationX: translationX, velocityX: velocityX)
+            }
+
+            AsyncFunction("handleGestureEnd") { (view: SwipeableView, translationX: CGFloat, velocityX: CGFloat) in
+                view.handleGestureEnd(translationX: translationX, velocityX: velocityX)
+            }
+        }
+    }
+}