react-native-tinyui 2.0.0 → 3.1.0

package/README.md

@@ -11,6 +11,7 @@ staying close to native APIs. It uses UIKit by default and SwiftUI where needed.
 | Component                          | What it does                                                   |
 | ---------------------------------- | -------------------------------------------------------------- |
 | [Menu](#menu)                      | Present native menus with actions, submenus, and sections       |
+| [SwipeActions](#swipeactions)      | Reveal native action buttons by swiping React Native rows      |
 | [Popover](#popover)                | Show interactive React Native content in a native popover      |
 | [TipKit](#tipkit)                  | Present contextual tips using Apple's TipKit framework         |
 | [LiquidGlassText](#liquidglasstext) | Render text with native glass effects inside the glyphs        |
@@ -75,12 +76,29 @@ use in your app's `package.json`:
 Available components:
 
 - `Menu`
+- `SwipeActions`
 - `Popover`
 - `LiquidGlassText`
 - `Stepper`
 - `ConcentricView`
 - `SFSymbol`
-- `TipKit` (enables `TipKit.Popover`, `TipKit.configure`, `TipKit.resetDatastore` and `TipKit.invalidate`)
+- `TipKit` (enables `TipKit.View`, `TipKit.Popover`, `TipKit.configure`, `TipKit.resetDatastore` and `TipKit.invalidate`)
+
+`TipKit` is one optional module containing both native views,
+`TinyuiTipPopoverView` and `TinyuiTipView`. Select it once in your app's
+`package.json` to include both:
+
+```json
+{
+  "react-native-tinyui": {
+    "components": ["TipKit"]
+  }
+}
+```
+
+The JavaScript API is also `TipKit`, imported from `react-native-tinyui` or
+`react-native-tinyui/tip-kit`. The library's Codegen configuration registers the
+two native view classes individually; it is not the optional-module selection.
 
 All components are enabled by default. Use an empty `components` array to
 compile only the TurboModule core. Run `pod install` again whenever this list
@@ -91,6 +109,7 @@ Component-specific JavaScript entry points are also available:
 
 ```tsx
 import { Menu } from 'react-native-tinyui/menu';
+import { SwipeActions } from 'react-native-tinyui/swipe-actions';
 import { Popover } from 'react-native-tinyui/popover';
 import { LiquidGlassText } from 'react-native-tinyui/liquid-glass-text';
 import { Stepper } from 'react-native-tinyui/stepper';
@@ -205,6 +224,62 @@ deprecated `titleColor` field is retained only for source compatibility; use
 `destructive` for system red styling. Submenus support the same label fields
 plus `destructive`, `disabled`, `hidden`, and `displayInline`.
 
+## SwipeActions
+
+`SwipeActions` wraps React Native row content in a native, non-scrolling
+`UITableView` row and uses `UISwipeActionsConfiguration`. It provides the edge
+and full-swipe behavior of SwiftUI's
+[`swipeActions`](https://developer.apple.com/documentation/swiftui/view/swipeactions(edge:allowsfullswipe:content:))
+without requiring a SwiftUI `List`. Use it inside a `FlatList` or `ScrollView`;
+Yoga measures the children, so a fixed row height is optional.
+
+```tsx
+import { SwipeActions } from 'react-native-tinyui/swipe-actions';
+
+<SwipeActions
+  edge="trailing"
+  allowsFullSwipe={false}
+  contentContainerStyle={{ backgroundColor: 'white', borderRadius: 12 }}
+  actions={[
+    { id: 'archive', title: 'Archive', systemImage: 'archivebox', tintColor: '#007AFF' },
+    { id: 'delete', title: 'Delete', systemImage: 'trash', destructive: true },
+  ]}
+  onActionPress={({ nativeEvent }) => handleAction(nativeEvent.id)}
+>
+  <Pressable onPress={openMessage} style={{ padding: 16 }}>
+    <Text>Weekend plans</Text>
+  </Pressable>
+</SwipeActions>;
+```
+
+| Prop | Description | Default |
+| --- | --- | --- |
+| `actions` | Ordered array of native buttons; an empty array disables swiping | Required |
+| `edge` | `leading` or `trailing`, following the row's layout direction | `trailing` |
+| `allowsFullSwipe` | A full swipe performs the **first** action | `true` |
+| `disabled` | Disables swipe actions while preserving child interactions | `false` |
+| `onActionPress` | Receives `{ nativeEvent: { id, title } }` | — |
+| `children` | React Native row content, including pressable children | Required |
+| `contentContainerStyle` | Styles the moving row, including its background, corners and padding | — |
+
+Each action accepts `title`, optional `id` (defaults to `item.<index>`),
+`systemImage` (SF Symbol), `tintColor` (button background), and `destructive`.
+IDs must be unique within the row; use explicit IDs when reordering actions.
+Colors support `PlatformColor` and `DynamicColorIOS`. Buttons appear from the
+selected edge inward in array order. `destructive` changes the native appearance;
+your callback decides whether to remove the row from React state.
+
+Standard `ViewProps` and a native view ref are supported. `style` applies to the
+stationary outer container; use it for layout, sizing and margins. Put the row's
+background, corners and padding in `contentContainerStyle` (or on your children)
+so they move with the content. A background on `style` stays behind the revealed
+actions. Keep stable list keys.
+Opening another `SwipeActions` row closes the previous one. Updating the action
+configuration, disabling, resizing or unmounting a row dismisses its actions.
+One edge is supported per wrapper; do not nest wrappers to add a second edge.
+This component hosts one native table per mounted row, so use list virtualization
+for large datasets. It does not expose SwiftUI's arbitrary action view content.
+
 ## Popover
 
 <img src="docs/screenshots/popover.png" alt="Popover displaying resizable content above its trigger" width="320" />
@@ -256,12 +331,16 @@ outer container, not the presented content.
 
 <img src="docs/screenshots/tip-kit.png" alt="TipKit popover with a save action anchored to the favorite button" width="320" />
 
+`TipKit.View` embeds a native `TipUIView` directly in your layout.
 `TipKit.Popover` anchors a native TipKit `TipUIPopoverViewController` to ordinary
 React Native children on iOS 17+. The children retain their own touch handlers;
 the tip appears automatically when both `enabled` and TipKit's eligibility allow
 it. Its text, SF Symbol, action buttons, display history and invalidation use
 Apple's TipKit framework. No additional package is required.
 
+Both components support the same tip content, action callbacks, display options
+and persistent history on iOS 17+.
+
 Configure TipKit once, **before mounting tips** (for example, during app startup):
 
 ```tsx
@@ -278,12 +357,18 @@ await TipKit.configure({ displayFrequency: 'daily' });
   systemImage="star"
   enabled={isScreenFocused && !hasFavorites}
   maxDisplayCount={3}
-  actions={[{ id: 'learn-more', title: 'Learn more' }]}
-  onActionPress={({ id }) => {
-    if (id === 'learn-more') openHelp();
+  actions={[
+    { id: 'save', title: 'Save this item' },
+    { id: 'learn-more', title: 'Learn more' },
+  ]}
+  onActionPress={async ({ id }) => {
+    if (id === 'save') {
+      await saveFavorite();
+      await TipKit.invalidate('favorite-feature-v1', 'actionPerformed');
+    } else if (id === 'learn-more') {
+      openHelp();
+    }
   }}
-  onStatusChange={(status) => console.log(status)}
-  onVisibleChange={(visible) => console.log({ visible })}
   onError={(error) => console.warn(error.message)}
 >
   <Pressable onPress={async () => {
@@ -295,28 +380,73 @@ await TipKit.configure({ displayFrequency: 'daily' });
 </TipKit.Popover>;
 ```
 
+For an inline tip, use `TipKit.View` without anchor children (after the same
+startup configuration):
+
+```tsx
+<TipKit.View
+  tipId="favorite-inline-v1"
+  title="Keep your favorites close"
+  message="Save an item to find it quickly next time."
+  systemImage="star"
+  enabled={isScreenFocused && !hasFavorites}
+  actions={[
+    { id: 'save', title: 'Save this item' },
+    { id: 'learn-more', title: 'Learn more' },
+  ]}
+  onActionPress={async ({ id }) => {
+    if (id === 'save') {
+      await saveFavorite();
+      await TipKit.invalidate('favorite-inline-v1', 'actionPerformed');
+    } else if (id === 'learn-more') {
+      openHelp();
+    }
+  }}
+/>
+```
+
+`TipKit.View` fills the available width and measures its native content height.
+The card keeps TipKit's preferred width within that space and aligns to the
+leading edge; the system also chooses the action buttons' layout.
+Give it a bounded width (for example, a stretched child of a column or an
+explicit `style.width`); no fixed height is needed. When disabled or ineligible,
+its content height becomes zero. Explicit height/min-height, padding, margins
+and a parent's `gap` still follow normal React Native layout rules. Native
+measurement updates Fabric directly, including after width and Dynamic Type
+changes; there is no JavaScript size or status callback. The inline arrow is
+optional: `arrowEdge` accepts `top`, `bottom`, `leading`, `trailing` or `none`
+(default). `children` is only supported by `TipKit.Popover`.
+
+The remaining props are shared by both components:
+
 | Prop | Description | Default |
 | --- | --- | --- |
 | `tipId` | Required stable identity for persistent history | — |
 | `title` | Required nonempty title, already localized by the app | — |
 | `message` | Supporting plain text | — |
 | `systemImage` | SF Symbol name | — |
-| `actions` | Buttons with unique nonempty `{ id, title }` values | `[]` |
+| `actions` | Native buttons with unique nonempty `id` and nonempty `title`; TipKit chooses their layout | `[]` |
 | `enabled` | Allows presentation; does not override TipKit eligibility | `true` |
 | `maxDisplayCount` | Positive integer; automatically invalidates after this many displays | Unlimited |
 | `ignoresDisplayFrequency` | Exempts this tip from the app-wide display interval | `false` |
-| `arrowEdge` | Preferred bubble edge: `top`, `bottom`, `leading`, `trailing`, `auto` | `auto` |
-| `onStatusChange` | `{ status: 'pending' \| 'available' }` or `{ status: 'invalidated', reason }` | — |
-| `onVisibleChange` | Whether the native bubble is actually visible | — |
+| `arrowEdge` | `top`, `bottom`, `leading`, `trailing`; Popover also accepts `auto`, View accepts `none` | Popover: `auto`; View: `none` |
 | `onActionPress` | Receives the selected `{ id, title }`; does not automatically invalidate | — |
 | `onError` | Receives `{ code, message }`; otherwise a warning is logged | — |
 
-The component accepts standard `ViewProps` and a native view ref. `style` lays
-out the anchor, not the bubble. UIKit chooses the bubble's size and may adapt
+Both components accept standard `ViewProps` and a native view ref. For Popover,
+`style` lays out the anchor, not the bubble. UIKit chooses the bubble's size and may adapt
 the arrow to available space; leading/trailing follow layout direction. Bubble
 content is native text/images/actions; `children` supplies only the anchor.
-Content edits apply to the next presentation; the currently visible bubble
-retains the content and action labels it was presented with.
+Content and arrow edits on an inline tip apply the next time it is shown.
+Content edits on a popover apply to the next presentation. A currently visible
+tip retains the content and action labels it was shown with.
+
+To show two action buttons, provide two entries in `actions`, as above. Each
+`title` controls that button's label. `onActionPress` receives the clicked
+button's `{ id, title }`; use `id` to handle the buttons separately. Titles may
+be translated without changing action IDs. To temporarily hide a tip in response
+to an action, set `enabled` to `false`; to permanently complete it, call
+`TipKit.invalidate`.
 
 ### Configuration and lifetime
 
@@ -326,7 +456,9 @@ app-wide TipKit setting. Repeating the same configuration is safe, including
 after Fast Refresh; changing it later rejects with `E_TIPS_ALREADY_CONFIGURED`.
 Coordinate this startup configuration with any other native TipKit integration.
 Initialization errors reject the promise; an enabled view mounted too early
-reports `E_TIPS_NOT_CONFIGURED` and can recover after configuration succeeds.
+reports `E_TIPS_NOT_CONFIGURED`. Await configuration before mounting tips. If a
+tip was already mounted, remount it or toggle `enabled` after configuration to
+start observing it.
 
 `TipKit.resetDatastore()` returns a promise and clears all persisted tip, event
 and parameter records, making previously invalidated tips eligible again when
@@ -348,25 +480,14 @@ launch will erase users' tip history on every launch.
 `TipKit.invalidate(tipId, reason = 'actionPerformed')` also returns a promise and
 requires configuration first. It persistently invalidates the ID even when no
 view for that tip is mounted. `reason` may be `actionPerformed` or `tipClosed`.
-System invalidations can additionally report `displayCountExceeded`,
-`displayDurationExceeded`, or `unknown` through `onStatusChange`.
 
-`onStatusChange` reports eligibility, independently of actual bubble visibility:
-
-| Status | Meaning |
-| --- | --- |
-| `pending` | Currently ineligible, such as while waiting for the display frequency interval |
-| `available` | Eligible; presentation still requires `enabled`, a visible anchor and a free presenter |
-| `invalidated` | Persistently ineligible, with an invalidation `reason`; does not recover just by remounting or restarting |
-
-Invalidation reasons are `actionPerformed` (explicitly call `invalidate` after
-the feature is used), `tipClosed` (the system close button or explicit
-invalidation), `displayCountExceeded` (the `maxDisplayCount` limit), and
-`displayDurationExceeded` (a native duration limit; this wrapper does not expose
-a duration option). `unknown` is a fallback for future native reasons.
+Both native views observe TipKit's `shouldDisplayUpdates` to show or remove
+the tip. Eligibility and visibility changes are not sent to JavaScript.
+Call `invalidate` with `actionPerformed` after the feature is used, or with
+`tipClosed` to permanently dismiss the tip. TipKit also handles the system
+close button and display limits.
 Action buttons only emit `onActionPress`; they do not automatically invalidate.
 Setting `enabled={false}` or unmounting a tip does not itself invalidate it.
-Use `onVisibleChange` to observe whether the bubble is actually on screen.
 
 Keep IDs stable across renders, app launches and translations. All instances
 with the same ID share their TipKit history. Keep `maxDisplayCount` and
@@ -375,16 +496,30 @@ with the same ID share their TipKit history. Keep `maxDisplayCount` and
 tip. Hiding a tip, unmounting it or reconfiguring TinyUI never resets history.
 
 Use `enabled={isScreenFocused && businessCondition}` with your navigation
-library. TinyUI also waits for a visible anchor and a free presenter, and
-dismisses on detachment or when the anchor leaves the visible area. It presents
-at most one TinyUI tip at a time and waits while another modal occupies the
-presenter. An outside dismissal suppresses immediate reopening for that mount;
-toggle `enabled` off and on to allow another attempt, subject to TipKit's state.
-The system close button can permanently invalidate a tip.
-
-This first version exposes popover tips and JS eligibility conditions. Inline
-`TipUIView`, native rule/event builders and TipGroup are
-not exposed. The example's **New demo tip** button deliberately creates another
+library. Each mounted, enabled Popover anchor starts its own `shouldDisplayUpdates`
+observation once it has a size and a parent view controller. Disabling,
+detaching or recycling the component stops observation and dismisses its
+bubble; changing `tipId` starts a new observation. This follows the independent
+`start()` / `stop()` structure of
+[Tipster's TipPresenter](https://github.com/chockenberry/Tipster/blob/081922aa9421d764c436cbe16ad9e2601cd52740/Tipster/TipKitHelper.swift).
+
+Popover presentation is skipped when the host view controller or an ancestor already
+presents another controller. There is no global anchor registry, presentation
+queue, polling timer, app-state observer or scroll visibility tracking.
+Closing another tip or modal does not automatically retry a skipped
+presentation. A later eligibility update, remount or re-enabling the component
+can trigger another attempt. An outside dismissal only cleans up the current
+presentation; there is no additional per-mount suppression policy. The system
+close button can permanently invalidate a tip.
+
+Inline tips start observing when attached to a window and stop when disabled,
+detached or recycled. They do not present a view controller or block interaction
+with the rest of the screen. Both presentations use the same datastore; an
+invalidation affects every instance of the same `tipId`.
+
+Native rule/event builders and TipGroup are not exposed. The example's
+**Inline view** switch toggles between both presentations. Its **New demo tip**
+button deliberately creates another
 ID for trying the behavior again without clearing the app's TipKit datastore.
 
 ## LiquidGlassText
@@ -668,7 +803,7 @@ visibility state changes apply instantly. Set it to `false` to opt out.
 
 ## Example App
 
-The [example app](example/src/App.tsx) demonstrates Menu, Popover, TipKit,
+The [example app](example/src/App.tsx) demonstrates Menu, SwipeActions, Popover, TipKit,
 LiquidGlassText, Stepper, ConcentricView, and SFSymbol. It includes all native
 components, so building it requires Xcode 26+. Use iOS 26+ to try the glass effects
 and the latest SF Symbol features.

package/ios/Core/Tinyui.mm

@@ -12,6 +12,9 @@
 #if TINYUI_FEATURE_MENU
   [components addObject:@"Menu"];
 #endif
+#if TINYUI_FEATURE_SWIPE_ACTIONS
+  [components addObject:@"SwipeActions"];
+#endif
 #if TINYUI_FEATURE_POPOVER
   [components addObject:@"Popover"];
 #endif

package/ios/Core/TinyuiComponentClasses.mm

@@ -29,6 +29,12 @@ TINYUI_DISABLED_COMPONENT(TinyuiMenuView, TinyuiMenuViewComponentDescriptor)
 TINYUI_DISABLED_COMPONENT(TinyuiPopoverView, TinyuiPopoverViewComponentDescriptor)
 #endif
 
+#if TINYUI_FEATURE_SWIPE_ACTIONS
+#import "TinyuiSwipeActionsView.h"
+#else
+TINYUI_DISABLED_COMPONENT(TinyuiSwipeActionsView, TinyuiSwipeActionsViewComponentDescriptor)
+#endif
+
 #if TINYUI_FEATURE_LIQUID_GLASS_TEXT
 #import "TinyuiLiquidGlassTextView.h"
 #else
@@ -55,8 +61,10 @@ TINYUI_DISABLED_COMPONENT(TinyuiSFSymbolView, TinyuiSFSymbolViewComponentDescrip
 
 #if TINYUI_FEATURE_TIP_KIT
 #import "TinyuiTipPopoverView.h"
+#import "TinyuiTipView.h"
 #else
 TINYUI_DISABLED_COMPONENT(TinyuiTipPopoverView, TinyuiTipPopoverViewComponentDescriptor)
+TINYUI_DISABLED_COMPONENT(TinyuiTipView, TinyuiTipViewComponentDescriptor)
 #endif
 
 #undef TINYUI_DISABLED_COMPONENT
@@ -66,6 +74,11 @@ Class<RCTComponentViewProtocol> TinyuiMenuViewCls(void)
   return TinyuiMenuView.class;
 }
 
+Class<RCTComponentViewProtocol> TinyuiSwipeActionsViewCls(void)
+{
+  return TinyuiSwipeActionsView.class;
+}
+
 Class<RCTComponentViewProtocol> TinyuiPopoverViewCls(void)
 {
   return TinyuiPopoverView.class;
@@ -95,3 +108,8 @@ Class<RCTComponentViewProtocol> TinyuiTipPopoverViewCls(void)
 {
   return TinyuiTipPopoverView.class;
 }
+
+Class<RCTComponentViewProtocol> TinyuiTipViewCls(void)
+{
+  return TinyuiTipView.class;
+}

package/ios/SwipeActions/TinyuiSwipeActionsView.h

@@ -0,0 +1,12 @@
+#if TINYUI_FEATURE_SWIPE_ACTIONS
+
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface TinyuiSwipeActionsView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/SwipeActions/TinyuiSwipeActionsView.mm

@@ -0,0 +1,289 @@
+#if TINYUI_FEATURE_SWIPE_ACTIONS
+
+#import "TinyuiSwipeActionsView.h"
+
+#import <React/RCTConvert.h>
+#import <React/RCTSurfacePointerHandler.h>
+#import <React/RCTSurfaceTouchHandler.h>
+#import <react/utils/FollyConvert.h>
+#import <react/renderer/components/TinyuiSpec/ComponentDescriptors.h>
+#import <react/renderer/components/TinyuiSpec/EventEmitters.h>
+#import <react/renderer/components/TinyuiSpec/Props.h>
+
+using namespace facebook::react;
+
+@interface TinyuiSwipeActionsView () <UITableViewDataSource, UITableViewDelegate>
+@end
+
+@implementation TinyuiSwipeActionsView {
+  UITableView *_tableView;
+  UITableViewCell *_cell;
+  UIView *_rowView;
+  NSArray<NSDictionary *> *_actions;
+  BOOL _leading;
+  BOOL _allowsFullSwipe;
+  BOOL _disabled;
+  BOOL _needsConfiguration;
+  BOOL _actionsPresented;
+  NSUInteger _configurationVersion;
+}
+
+// UIKit normally coordinates open rows within one table. Each React row has
+// its own table, so coordinate them without retaining mounted Fabric views.
+static __weak TinyuiSwipeActionsView *activeSwipeView;
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<TinyuiSwipeActionsViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = std::make_shared<const TinyuiSwipeActionsViewProps>();
+    _actions = @[];
+    _allowsFullSwipe = YES;
+
+    _cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:nil];
+    _cell.backgroundColor = UIColor.clearColor;
+    _cell.contentView.backgroundColor = UIColor.clearColor;
+    _cell.selectionStyle = UITableViewCellSelectionStyleNone;
+    _cell.isAccessibilityElement = NO;
+
+    _tableView = [[UITableView alloc] initWithFrame:CGRectZero style:UITableViewStylePlain];
+    _tableView.backgroundColor = UIColor.clearColor;
+    _tableView.separatorStyle = UITableViewCellSeparatorStyleNone;
+    _tableView.scrollEnabled = NO;
+    _tableView.showsVerticalScrollIndicator = NO;
+    _tableView.showsHorizontalScrollIndicator = NO;
+    _tableView.bounces = NO;
+    _tableView.delaysContentTouches = NO;
+    _tableView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
+    _tableView.insetsContentViewsToSafeArea = NO;
+    _tableView.sectionHeaderTopPadding = 0;
+    _tableView.estimatedRowHeight = 0;
+    _tableView.estimatedSectionHeaderHeight = 0;
+    _tableView.estimatedSectionFooterHeight = 0;
+    _tableView.dataSource = self;
+    _tableView.delegate = self;
+    // Cover the entire row. Yoga owns the child's frame, including any padding;
+    // using RCTView's inset contentView frame would apply that padding twice.
+    [self addSubview:_tableView];
+  }
+  return self;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                         index:(NSInteger)index
+{
+  _rowView = childComponentView;
+  [_cell.contentView addSubview:childComponentView];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                           index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+  if (_rowView == childComponentView) {
+    _rowView = nil;
+    [self closeActions];
+  }
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  UISemanticContentAttribute direction = _layoutMetrics.layoutDirection == LayoutDirection::RightToLeft
+      ? UISemanticContentAttributeForceRightToLeft
+      : UISemanticContentAttributeForceLeftToRight;
+  if (!CGSizeEqualToSize(_tableView.bounds.size, self.bounds.size) ||
+      _tableView.semanticContentAttribute != direction) {
+    [self closeActions];
+  }
+  _tableView.frame = self.bounds;
+  CGFloat height = MAX(1, CGRectGetHeight(self.bounds));
+  if (_tableView.rowHeight != height) {
+    _tableView.rowHeight = height;
+    [_tableView reloadData];
+  }
+  // Map Yoga's resolved direction to UIKit's logical leading/trailing edges.
+  _tableView.semanticContentAttribute = direction;
+}
+
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  UIView *hit = [super hitTest:point withEvent:event];
+  // A tap on the exposed row dismisses its actions. Keep that tap in UIKit,
+  // rather than also activating a React child while the row is sliding back.
+  if (_actionsPresented && _rowView != nil && [hit isDescendantOfView:_rowView]) {
+    return _cell.contentView;
+  }
+  return hit;
+}
+
+- (SharedTouchEventEmitter)touchEventEmitterAtPoint:(CGPoint)point
+{
+  // Native action buttons have no Fabric ancestor until this view. Do not let
+  // their taps bubble to an outer React Pressable. Child React views still own
+  // normal row touches and keep their usual event bubbling.
+  return _actionsPresented ? nullptr : [super touchEventEmitterAtPoint:point];
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &previous = *std::static_pointer_cast<const TinyuiSwipeActionsViewProps>(_props);
+  const auto &next = *std::static_pointer_cast<const TinyuiSwipeActionsViewProps>(props);
+  if (_needsConfiguration || previous.actionsConfig != next.actionsConfig || previous.edge != next.edge ||
+      previous.allowsFullSwipe != next.allowsFullSwipe || previous.disabled != next.disabled) {
+    [self closeActions];
+    id config = convertFollyDynamicToId(next.actionsConfig);
+    _actions = [config isKindOfClass:NSArray.class] ? config : @[];
+    _leading = next.edge == TinyuiSwipeActionsViewEdge::Leading;
+    _allowsFullSwipe = next.allowsFullSwipe;
+    _disabled = next.disabled;
+    _needsConfiguration = NO;
+  }
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
+{
+  return 1;
+}
+
+- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  return _cell;
+}
+
+- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  return !_disabled && _actions.count > 0 && _rowView != nil;
+}
+
+- (UISwipeActionsConfiguration *)tableView:(UITableView *)tableView
+    leadingSwipeActionsConfigurationForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  return _leading ? [self swipeConfiguration] : nil;
+}
+
+- (UISwipeActionsConfiguration *)tableView:(UITableView *)tableView
+    trailingSwipeActionsConfigurationForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  return _leading ? nil : [self swipeConfiguration];
+}
+
+- (UISwipeActionsConfiguration *)swipeConfiguration
+{
+  if (_disabled || _actions.count == 0 || _rowView == nil) {
+    return nil;
+  }
+
+  NSMutableArray<UIContextualAction *> *actions = [NSMutableArray array];
+  NSUInteger version = _configurationVersion;
+  __weak TinyuiSwipeActionsView *weakSelf = self;
+  for (NSDictionary *item in _actions) {
+    if (![item isKindOfClass:NSDictionary.class] ||
+        ![item[@"id"] isKindOfClass:NSString.class] ||
+        ![item[@"title"] isKindOfClass:NSString.class]) {
+      continue;
+    }
+    NSString *identifier = item[@"id"];
+    NSString *title = item[@"title"];
+    UIContextualActionStyle style = [item[@"destructive"] boolValue]
+        ? UIContextualActionStyleDestructive : UIContextualActionStyleNormal;
+    UIContextualAction *action = [UIContextualAction contextualActionWithStyle:style
+        title:title handler:^(UIContextualAction *selectedAction, UIView *sourceView,
+                              void (^completionHandler)(BOOL)) {
+      TinyuiSwipeActionsView *view = weakSelf;
+      if (view == nil || view->_disabled || view.window == nil || view->_rowView == nil ||
+          version != view->_configurationVersion) {
+        completionHandler(NO);
+        return;
+      }
+      // Finish UIKit's interaction before JS can update or remove the row.
+      completionHandler(YES);
+      if (view->_eventEmitter != nullptr) {
+        std::static_pointer_cast<const TinyuiSwipeActionsViewEventEmitter>(view->_eventEmitter)
+            ->onActionPress(TinyuiSwipeActionsViewEventEmitter::OnActionPress{
+                .id = std::string(identifier.UTF8String ?: ""),
+                .title = std::string(title.UTF8String ?: "")});
+      }
+    }];
+    if ([item[@"systemImage"] isKindOfClass:NSString.class]) {
+      action.image = [UIImage systemImageNamed:item[@"systemImage"]];
+    }
+    if (item[@"tintColor"] != nil && item[@"tintColor"] != NSNull.null) {
+      action.backgroundColor = [RCTConvert UIColor:item[@"tintColor"]];
+    }
+    [actions addObject:action];
+  }
+  UISwipeActionsConfiguration *configuration = [UISwipeActionsConfiguration configurationWithActions:actions];
+  configuration.performsFirstActionWithFullSwipe = _allowsFullSwipe;
+  return configuration;
+}
+
+- (void)tableView:(UITableView *)tableView willBeginEditingRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  _actionsPresented = YES;
+  // Fabric keeps observing touches handled by recognizers inside its surface.
+  // Once UIKit starts a swipe, cancel that React sequence so a child/ancestor
+  // Pressable cannot also complete an onPress when the finger is lifted.
+  for (UIView *view = self; view != nil; view = view.superview) {
+    for (UIGestureRecognizer *recognizer in view.gestureRecognizers) {
+      if (recognizer.enabled &&
+          ([recognizer isKindOfClass:RCTSurfaceTouchHandler.class] ||
+           [recognizer isKindOfClass:RCTSurfacePointerHandler.class])) {
+        recognizer.enabled = NO;
+        recognizer.enabled = YES;
+      }
+    }
+  }
+  if (activeSwipeView != self) {
+    [activeSwipeView closeActions];
+  }
+  activeSwipeView = self;
+}
+
+- (void)tableView:(UITableView *)tableView didEndEditingRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  _actionsPresented = NO;
+  if (activeSwipeView == self) {
+    activeSwipeView = nil;
+  }
+}
+
+- (void)closeActions
+{
+  _configurationVersion += 1;
+  _actionsPresented = NO;
+  [_tableView setEditing:NO animated:NO];
+  if (activeSwipeView == self) {
+    activeSwipeView = nil;
+  }
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  if (self.window == nil) {
+    [self closeActions];
+  }
+}
+
+- (void)prepareForRecycle
+{
+  [self closeActions];
+  [_rowView removeFromSuperview];
+  _rowView = nil;
+  _actions = @[];
+  _leading = NO;
+  _allowsFullSwipe = YES;
+  _disabled = NO;
+  _needsConfiguration = YES;
+  [super prepareForRecycle];
+}
+
+@end
+
+#endif