react-native-swipeable-actions 0.1.10 → 0.1.12

package/ios/SwipeableView.swift

@@ -66,8 +66,25 @@ public class SwipeableView: ExpoView {
         registryQueue.async(flags: .barrier) { _viewRegistry[key] = WeakRef(view) }
     }
 
-    private static func unregisterView(for key: String) {
-        registryQueue.async(flags: .barrier) { _viewRegistry.removeValue(forKey: key) }
+    private static func unregisterView(_ view: SwipeableView, for key: String) {
+        // Identity-check: a newer SwipeableView may have already taken over this
+        // key (FlashList remounts a new instance before the old one's deinit
+        // fires). Without this guard the old view's deinit blindly removes the
+        // key, leaving the new view orphaned in the registry — closeByKey for
+        // that key then returns nil and the visible row can't be closed.
+        //
+        // Capture identity as a *value* (ObjectIdentifier), never reference
+        // `view` inside the async closure. Callers include `deinit`, where
+        // `self` is mid-deallocation; strongly capturing it in an escaping
+        // closure produces a zombie reference and crashes (EXC_BAD_ACCESS) when
+        // the barrier finally runs after the object has been freed.
+        let identity = ObjectIdentifier(view)
+        registryQueue.async(flags: .barrier) {
+            if let registered = _viewRegistry[key]?.value,
+               ObjectIdentifier(registered) == identity {
+                _viewRegistry.removeValue(forKey: key)
+            }
+        }
     }
 
     private static func clearOpenState(for key: String) {
@@ -88,7 +105,15 @@ public class SwipeableView: ExpoView {
 
     static func closeByKey(_ key: String, animated: Bool = true) {
         DispatchQueue.main.async {
-            getView(for: key)?.close(animated: animated)
+            if let view = getView(for: key) {
+                view.close(animated: animated)
+            } else {
+                // View was recycled away (or unregistered) before this close
+                // could run. Update the cache directly so a future cell binding
+                // to this key starts closed instead of inheriting a stale open
+                // state — see recyclingKey setter for the matching invariant.
+                setOpenState(for: key, isOpen: false)
+            }
         }
     }
 
@@ -229,10 +254,15 @@ public class SwipeableView: ExpoView {
             let shouldOpen = recyclingKey.map { Self.getOpenState(for: $0) } ?? false
             pendingShouldOpen = shouldOpen
 
-            // Thread-safe write of old key's state and unregister
+            // Unregister from the old key. We intentionally do NOT write back
+            // `isOpen` here: open() and close() already maintain the cache when
+            // the user actually triggers the state change. Writing the view's
+            // current `isOpen` at reassignment time captures stale state when a
+            // pending async close hasn't run yet, leaving the old key cached as
+            // open forever — the next cell binding to it would snap open
+            // without any user intent.
             if let old = oldValue {
-                Self.setOpenState(for: old, isOpen: isOpen)
-                Self.unregisterView(for: old)
+                Self.unregisterView(self, for: old)
             }
 
             // Thread-safe register with new key
@@ -261,9 +291,6 @@ public class SwipeableView: ExpoView {
     // Auto-close work item for tracking and cancellation
     private var autoCloseWorkItem: DispatchWorkItem?
 
-    // Override onSwipeEnd state when autoClose triggers close() (emit "open" instead of "closed")
-    private var autoCloseEndEventOverride = false
-
     // UIViewPropertyAnimator for interruptible animations (2.1, 2.2)
     private var currentAnimator: UIViewPropertyAnimator?
 
@@ -307,7 +334,7 @@ public class SwipeableView: ExpoView {
         removeGestureRecognizer(panGesture)
         // Thread-safe deregister from view registry
         if let key = recyclingKey {
-            Self.unregisterView(for: key)
+            Self.unregisterView(self, for: key)
         }
     }
 
@@ -340,7 +367,7 @@ public class SwipeableView: ExpoView {
 
             // Unregister from static registry and clear cached state
             if let key = recyclingKey {
-                Self.unregisterView(for: key)
+                Self.unregisterView(self, for: key)
                 Self.clearOpenState(for: key)
             }
         }
@@ -451,8 +478,7 @@ public class SwipeableView: ExpoView {
             DispatchQueue.main.asyncAfter(deadline: .now() + 0.1, execute: retryWorkItem)
         } else if isOpen {
             // Emit "open" state when autoClose completes - user's swipe intent was achieved
-            autoCloseEndEventOverride = true
-            close()
+            close(autoCloseOverride: true)
         }
     }
 
@@ -516,12 +542,27 @@ public class SwipeableView: ExpoView {
     // views that UIView.subviews would otherwise include.
     public override func mountChildComponentView(_ childComponentView: UIView, index: Int) {
         super.mountChildComponentView(childComponentView, index: index)
+        // Incoming child may carry a stale transform/zPosition from Fabric recycling;
+        // reset it (refreshChildAssignments re-applies the open transform when open).
+        childComponentView.transform = .identity
+        childComponentView.layer.zPosition = 0
         let clampedIndex = min(max(index, 0), reactChildren.count)
         reactChildren.insert(childComponentView, at: clampedIndex)
         refreshChildAssignments()
     }
 
     public override func unmountChildComponentView(_ childComponentView: UIView, index: Int) {
+        // Content recycled mid-animation: stop the animator before contentView is
+        // nil'd below, else it keeps writing a transform onto the pooled view.
+        // (Android skips this — RN zeroes translationX on recycle; port if needed.)
+        if childComponentView === contentView {
+            currentAnimator?.stopAnimation(true)
+            currentAnimator = nil
+            isAnimating = false
+            stopProgressUpdates()
+            cancelAutoClose()  // a pending timer would fire on the reused view
+        }
+
         // Fabric recycles UIView instances. Before handing this child back, undo any
         // transform / zPosition we may have applied — otherwise the next React
         // component that receives this recycled UIView inherits our stale state and
@@ -877,7 +918,9 @@ public class SwipeableView: ExpoView {
         onSwipeProgress(["progress": 1.0, "translationX": targetX])
     }
 
-    func close(animated: Bool = true, velocity: CGFloat = 0) {
+    // autoCloseOverride is a value, not a sticky flag: an interrupted close (which
+    // never runs the completion) can't strand it and mislabel a later close as "open".
+    func close(animated: Bool = true, velocity: CGFloat = 0, autoCloseOverride: Bool = false) {
         cancelAutoClose()
         stopProgressUpdates()
 
@@ -921,8 +964,7 @@ public class SwipeableView: ExpoView {
                 self.actionsView?.transform = CGAffineTransform(translationX: actionsOffset, y: 0)
                 self.onSwipeProgress(["progress": 0.0, "translationX": 0.0])
                 // Emit "open" when autoClose completes - user's swipe intent was achieved
-                let endState = self.autoCloseEndEventOverride ? "open" : "closed"
-                self.autoCloseEndEventOverride = false
+                let endState = autoCloseOverride ? "open" : "closed"
                 self.onSwipeEnd(["state": endState])
 
                 // Restore first responder if it was lost during swipe (keyboard preservation)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-swipeable-actions",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "High-performance native swipeable row component for React Native using Expo Modules",
   "main": "src/index.ts",
   "types": "build/index.d.ts",