react-native-tinyui 1.1.1 → 3.0.0

package/ios/SFSymbol/TinyuiSFSymbolProvider.swift

@@ -0,0 +1,135 @@
+import React
+import Symbols
+import UIKit
+
+@objc(TinyuiSFSymbolProvider)
+public final class TinyuiSFSymbolProvider: UIImageView {
+  private var configuration: NSDictionary?
+  private var effects: [[String: Any]] = []
+  private var appliedEffects: [String: [String: Any]] = [:]
+  private var respectReduceMotion = true
+
+  public override init(frame: CGRect) {
+    super.init(frame: frame)
+    contentMode = .center
+    isAccessibilityElement = false
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(reduceMotionChanged),
+      name: UIAccessibility.reduceMotionStatusDidChangeNotification,
+      object: nil
+    )
+  }
+
+  @available(*, unavailable)
+  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+  private var reduceMotion: Bool {
+    respectReduceMotion && UIAccessibility.isReduceMotionEnabled
+  }
+
+  @objc(configure:effects:contentTransition:respectReduceMotion:resizeMode:)
+  public func configure(
+    _ value: Any?,
+    effects: Any?,
+    contentTransition: Any?,
+    respectReduceMotion: Bool,
+    resizeMode: String
+  ) {
+    let changedMotion = self.respectReduceMotion != respectReduceMotion
+    self.respectReduceMotion = respectReduceMotion
+    if changedMotion { clearEffects() }
+
+    let next = value as? [String: Any] ?? [:]
+    if configuration?.isEqual(to: next) != true {
+      let nextImage = TinyuiSFSymbolImage.image(configuration: next, includeColors: true)
+      tintColor = next["color"].flatMap(RCTConvert.uiColor) ?? .label
+      let transitionConfiguration = contentTransition as? [String: Any] ?? [:]
+      if let nextImage, image != nil, window != nil, !reduceMotion,
+        let transition = tinyuiSFSymbolTransition(transitionConfiguration)
+      {
+        setSymbolImage(
+          nextImage,
+          contentTransition: transition,
+          options: tinyuiSFSymbolOptions(transitionConfiguration)
+        )
+      } else {
+        image = nextImage
+      }
+      configuration = next as NSDictionary
+      if nextImage == nil { clearEffects() }
+    }
+
+    switch resizeMode {
+    case "contain": contentMode = .scaleAspectFit
+    case "cover": contentMode = .scaleAspectFill
+    case "stretch": contentMode = .scaleToFill
+    default: contentMode = .center
+    }
+    self.effects = effects as? [[String: Any]] ?? []
+  }
+
+  @objc public func clearEffects() {
+    removeAllSymbolEffects(options: .default, animated: false)
+    appliedEffects.removeAll()
+  }
+
+  @objc public func applyEffects() {
+    guard window != nil, image != nil else { return }
+    var requested: [String: [String: Any]] = [:]
+    for configuration in effects {
+      guard let type = configuration["type"] as? String else { continue }
+      requested[type] = configuration
+    }
+    for (type, old) in appliedEffects {
+      let next = requested[type]
+      if next.map({ NSDictionary(dictionary: old).isEqual(to: $0) }) != true
+        || (next?["active"] as? NSNumber)?.boolValue == false
+      {
+        // Reset immediately when replaying/reconfiguring so removal cannot race
+        // the replacement effect. Only animate an actual deactivation.
+        let reapplying = next != nil && (next?["active"] as? NSNumber)?.boolValue != false
+        let animated = !reapplying && !reduceMotion
+          && ((next ?? old)["animated"] as? NSNumber)?.boolValue != false
+        TinyuiSFSymbolEffect.make(old)?.remove(
+          from: self,
+          options: tinyuiSFSymbolOptions((next ?? old)["options"] as? [String: Any]),
+          animated: animated
+        )
+        appliedEffects.removeValue(forKey: type)
+      }
+    }
+    for (type, configuration) in requested {
+      if (configuration["active"] as? NSNumber)?.boolValue == false
+        || appliedEffects[type].map({ NSDictionary(dictionary: $0).isEqual(to: configuration) }) == true
+      {
+        continue
+      }
+      let stateful = ["scale", "appear", "disappear", "drawOn", "drawOff"].contains(type)
+      // Keep visibility/scale state under Reduce Motion without animating it.
+      if reduceMotion && !stateful { continue }
+      guard let effect = TinyuiSFSymbolEffect.make(configuration) else { continue }
+      effect.add(
+        to: self,
+        options: tinyuiSFSymbolOptions(configuration["options"] as? [String: Any]),
+        animated: !reduceMotion && (configuration["animated"] as? NSNumber)?.boolValue != false
+      )
+      appliedEffects[type] = configuration
+    }
+  }
+
+  public override func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window == nil { clearEffects() }
+    else { applyEffects() }
+  }
+
+  @objc private func reduceMotionChanged() {
+    clearEffects()
+    applyEffects()
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+}

package/ios/SFSymbol/TinyuiSFSymbolShadowNode.mm

@@ -1,7 +1,7 @@
 #if TINYUI_FEATURE_SF_SYMBOL
 
 #import "TinyuiSFSymbolShadowNode.h"
-#import "TinyuiSFSymbolImage.h"
+#import "Tinyui-Swift.h"
 #import <react/utils/FollyConvert.h>
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/core/LayoutContext.h>
@@ -16,7 +16,9 @@ Size TinyuiSFSymbolShadowNode::measureContent(
   @autoreleasepool {
     // UIImage and UIFont creation are safe off the main thread. No UIView or
     // main-queue sync is needed during concurrent Fabric layout.
-    UIImage *image = TinyuiSFSymbolImage(convertFollyDynamicToId(getConcreteProps().configuration), NO);
+    id configuration = convertFollyDynamicToId(getConcreteProps().configuration);
+    if (![configuration isKindOfClass:NSDictionary.class]) configuration = @{};
+    UIImage *image = [TinyuiSFSymbolImage imageWithConfiguration:configuration includeColors:NO];
     CGSize size = image == nil ? CGSizeZero : image.size;
     auto scale = layoutContext.pointScaleFactor > 0 ? layoutContext.pointScaleFactor : 1;
     return layoutConstraints.clamp({

package/ios/SFSymbol/TinyuiSFSymbolView.mm

@@ -1,10 +1,8 @@
 #if TINYUI_FEATURE_SF_SYMBOL
 
 #import "TinyuiSFSymbolView.h"
-#import "TinyuiSFSymbolEffects.h"
-#import "TinyuiSFSymbolImage.h"
 #import "TinyuiSFSymbolShadowNode.h"
-#import <React/RCTConvert.h>
+#import "Tinyui-Swift.h"
 #import <react/utils/FollyConvert.h>
 #import <react/renderer/components/TinyuiSpec/Props.h>
 #import <react/renderer/components/TinyuiSpec/RCTComponentViewHelpers.h>
@@ -15,11 +13,7 @@ using namespace facebook::react;
 @end
 
 @implementation TinyuiSFSymbolView {
-  UIImageView *_imageView;
-  NSDictionary *_configuration;
-  NSArray<NSDictionary *> *_effects;
-  NSMutableDictionary<NSString *, NSDictionary *> *_appliedEffects;
-  BOOL _respectReduceMotion;
+  TinyuiSFSymbolProvider *_provider;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider
@@ -31,141 +25,39 @@ using namespace facebook::react;
 {
   if (self = [super initWithFrame:frame]) {
     _props = std::make_shared<const TinyuiSFSymbolViewProps>();
-    [self createImageView];
-    [NSNotificationCenter.defaultCenter addObserver:self selector:@selector(reduceMotionChanged:)
-        name:UIAccessibilityReduceMotionStatusDidChangeNotification object:nil];
+    [self createProvider];
   }
   return self;
 }
 
-- (void)createImageView
+- (void)createProvider
 {
-  _imageView = [UIImageView new];
-  _imageView.contentMode = UIViewContentModeCenter;
-  _imageView.isAccessibilityElement = NO;
-  self.contentView = _imageView;
-  _configuration = nil;
-  _effects = @[];
-  _appliedEffects = [NSMutableDictionary dictionary];
-  _respectReduceMotion = YES;
-}
-
-- (BOOL)reduceMotion
-{
-  return _respectReduceMotion && UIAccessibilityIsReduceMotionEnabled();
+  _provider = [[TinyuiSFSymbolProvider alloc] initWithFrame:CGRectZero];
+  self.contentView = _provider;
 }
 
 - (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
 {
   const auto &next = *std::static_pointer_cast<const TinyuiSFSymbolViewProps>(props);
-  BOOL changedMotion = _respectReduceMotion != next.respectReduceMotion;
-  _respectReduceMotion = next.respectReduceMotion;
-  if (changedMotion) [self clearEffects];
-
-  NSDictionary *configuration = convertFollyDynamicToId(next.configuration);
-  if (![configuration isKindOfClass:NSDictionary.class]) configuration = @{};
-  if (![_configuration isEqual:configuration]) {
-    UIImage *image = TinyuiSFSymbolImage(configuration, YES);
-    _imageView.tintColor = [RCTConvert UIColor:configuration[@"color"]] ?: UIColor.labelColor;
-    NSDictionary *transitionConfig = convertFollyDynamicToId(next.contentTransition);
-    if (![transitionConfig isKindOfClass:NSDictionary.class]) transitionConfig = @{};
-    NSSymbolContentTransition *transition = TinyuiSFSymbolTransition(transitionConfig);
-    if (image != nil && _imageView.image != nil && self.window != nil && transition != nil && !self.reduceMotion) {
-      [_imageView setSymbolImage:image withContentTransition:transition
-          options:TinyuiSFSymbolOptions(transitionConfig)];
-    } else {
-      _imageView.image = image;
-    }
-    _configuration = configuration;
-    if (image == nil) [self clearEffects];
-  }
-
-  if (next.resizeMode == "contain") _imageView.contentMode = UIViewContentModeScaleAspectFit;
-  else if (next.resizeMode == "cover") _imageView.contentMode = UIViewContentModeScaleAspectFill;
-  else if (next.resizeMode == "stretch") _imageView.contentMode = UIViewContentModeScaleToFill;
-  else _imageView.contentMode = UIViewContentModeCenter;
-
-  id effects = convertFollyDynamicToId(next.effects);
-  _effects = [effects isKindOfClass:NSArray.class] ? effects : @[];
+  [_provider configure:convertFollyDynamicToId(next.configuration)
+               effects:convertFollyDynamicToId(next.effects)
+     contentTransition:convertFollyDynamicToId(next.contentTransition)
+   respectReduceMotion:next.respectReduceMotion
+            resizeMode:[NSString stringWithUTF8String:next.resizeMode.c_str()]];
   [super updateProps:props oldProps:oldProps];
 }
 
 - (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask
 {
   [super finalizeUpdates:updateMask];
-  [self applyEffects];
-}
-
-- (void)clearEffects
-{
-  [_imageView removeAllSymbolEffectsWithOptions:NSSymbolEffectOptions.options animated:NO];
-  [_appliedEffects removeAllObjects];
-}
-
-- (void)applyEffects
-{
-  if (self.window == nil || _imageView.image == nil) return;
-  NSMutableDictionary<NSString *, NSDictionary *> *requested = [NSMutableDictionary dictionary];
-  for (NSDictionary *configuration in _effects) {
-    if (![configuration isKindOfClass:NSDictionary.class]) continue;
-    NSString *type = configuration[@"type"];
-    if (![type isKindOfClass:NSString.class]) continue;
-    requested[type] = configuration;
-  }
-  for (NSString *type in _appliedEffects.allKeys) {
-    NSDictionary *old = _appliedEffects[type];
-    NSDictionary *next = requested[type];
-    if (![old isEqual:next] || [next[@"active"] isEqual:@NO]) {
-      NSSymbolEffect *effect = TinyuiSFSymbolEffect(old);
-      // Reset immediately when replaying/reconfiguring, so an animated removal
-      // cannot race the replacement effect. Animate only actual deactivation.
-      BOOL reapplying = next != nil && ![next[@"active"] isEqual:@NO];
-      BOOL animated = !reapplying && !self.reduceMotion && ![(next ?: old)[@"animated"] isEqual:@NO];
-      if (effect != nil) {
-        [_imageView removeSymbolEffectOfType:effect
-            options:TinyuiSFSymbolOptions((next ?: old)[@"options"]) animated:animated];
-      }
-      [_appliedEffects removeObjectForKey:type];
-    }
-  }
-  for (NSString *type in requested) {
-    NSDictionary *configuration = requested[type];
-    if ([configuration[@"active"] isEqual:@NO] || [_appliedEffects[type] isEqual:configuration]) continue;
-    BOOL stateful = [@[@"scale", @"appear", @"disappear", @"drawOn", @"drawOff"] containsObject:type];
-    // Keep visibility/scale state under Reduce Motion, without continuous or
-    // discrete animation. Clearing those effects must still restore the state.
-    if (self.reduceMotion && !stateful) continue;
-    NSSymbolEffect *effect = TinyuiSFSymbolEffect(configuration);
-    if (effect == nil) continue;
-    [_imageView addSymbolEffect:effect options:TinyuiSFSymbolOptions(configuration[@"options"])
-        animated:!self.reduceMotion && ![configuration[@"animated"] isEqual:@NO]];
-    _appliedEffects[type] = configuration;
-  }
-}
-
-- (void)didMoveToWindow
-{
-  [super didMoveToWindow];
-  if (self.window == nil) [self clearEffects];
-  else [self applyEffects];
-}
-
-- (void)reduceMotionChanged:(NSNotification *)notification
-{
-  [self clearEffects];
-  [self applyEffects];
+  [_provider applyEffects];
 }
 
 - (void)prepareForRecycle
 {
-  [self clearEffects];
+  [_provider clearEffects];
   [super prepareForRecycle];
-  [self createImageView];
-}
-
-- (void)dealloc
-{
-  [NSNotificationCenter.defaultCenter removeObserver:self];
+  [self createProvider];
 }
 
 @end

package/ios/TipKit/TinyuiTip.swift

@@ -29,3 +29,19 @@ struct TinyuiTip: Tip, Sendable {
     return result
   }
 }
+
+extension TinyuiTip {
+  init(configuration: [String: Any]) {
+    self.init(
+      id: configuration["tipId"] as? String ?? "",
+      titleString: configuration["title"] as? String ?? "",
+      messageString: configuration["message"] as? String ?? "",
+      symbolName: configuration["systemImage"] as? String ?? "",
+      actionContents: (configuration["actions"] as? [[String: String]] ?? []).map {
+        ActionContent(id: $0["id"] ?? "", title: $0["title"] ?? "")
+      },
+      maximumDisplayCount: configuration["maxDisplayCount"] as? Int ?? 0,
+      ignoresFrequency: configuration["ignoresDisplayFrequency"] as? Bool ?? false
+    )
+  }
+}

package/ios/TipKit/TinyuiTipPopoverProvider.swift

@@ -2,8 +2,6 @@ import TipKit
 import UIKit
 
 @objc public protocol TinyuiTipPopoverDelegate: AnyObject {
-  func onTipStatus(tipId: String, status: String, reason: String)
-  func onTipVisible(tipId: String, visible: Bool)
   func onTipAction(tipId: String, id: String, title: String)
   func onTipError(tipId: String, code: String, message: String)
 }
@@ -12,21 +10,22 @@ import UIKit
 @objc public final class TinyuiTipPopoverProvider: UIView, UIPopoverPresentationControllerDelegate {
   private weak var delegate: TinyuiTipPopoverDelegate?
   @objc public weak var parentViewController: UIViewController? {
-    didSet { TinyuiTipsRuntime.shared.requestUpdate() }
+    didSet {
+      guard oldValue !== parentViewController else { return }
+      stop()
+      start()
+    }
   }
   private var tip: TinyuiTip?
   private var enabled = false
   private var arrowEdge = "auto"
   private var observation: Task<Void, Never>?
-  private var observationGeneration = 0
-  private var status: Tips.Status?
+  private var shouldDisplay = false
   private var lastError: String?
-  private var suppressed = false
   private var controller: TipUIPopoverViewController?
   private var presentedTipId: String?
   private var isPresenting = false
   private var isDismissing = false
-  private var reportedVisible = false
 
   @objc public convenience init(delegate: TinyuiTipPopoverDelegate) {
     self.init(frame: .zero)
@@ -34,60 +33,48 @@ import UIKit
   }
 
   @objc public func configure(_ configuration: [String: Any], enabled: Bool, arrowEdge: String) {
-    let nextTip = TinyuiTip(
-      id: configuration["tipId"] as? String ?? "",
-      titleString: configuration["title"] as? String ?? "",
-      messageString: configuration["message"] as? String ?? "",
-      symbolName: configuration["systemImage"] as? String ?? "",
-      actionContents: (configuration["actions"] as? [[String: String]] ?? []).map {
-        TinyuiTip.ActionContent(id: $0["id"] ?? "", title: $0["title"] ?? "")
-      },
-      maximumDisplayCount: configuration["maxDisplayCount"] as? Int ?? 0,
-      ignoresFrequency: configuration["ignoresDisplayFrequency"] as? Bool ?? false
-    )
-    if tip?.id != nextTip.id {
-      stopObservation()
-      status = nil
+    let nextTip = TinyuiTip(configuration: configuration)
+    if tip?.id != nextTip.id || self.enabled != enabled {
+      stop()
       lastError = nil
-      suppressed = false
     }
-    if !self.enabled && enabled { suppressed = false }
     tip = nextTip
     self.enabled = enabled
     self.arrowEdge = arrowEdge
-    TinyuiTipsRuntime.shared.requestUpdate()
+    // Validate changed options even when an observation is already running.
+    do {
+      try TinyuiTipsRuntime.shared.remember(nextTip)
+    } catch {
+      stop()
+      let error = error as NSError
+      reportError(error.userInfo["code"] as? String ?? "E_TIP", error.localizedDescription)
+      return
+    }
+    lastError = nil
+    configureArrow()
+    start()
   }
 
   override public func didMoveToWindow() {
     super.didMoveToWindow()
-    if window == nil {
-      stopObservation()
-      dismissTip()
-      TinyuiTipsRuntime.shared.unregister(self)
-    } else {
-      TinyuiTipsRuntime.shared.register(self)
-    }
+    if window == nil { stop() } else { start() }
   }
 
   override public func layoutSubviews() {
     super.layoutSubviews()
     configureArrow()
-    TinyuiTipsRuntime.shared.requestUpdate()
+    // Start once Fabric has given the anchor a size. Layout changes alone do
+    // not request another presentation after a tip has been dismissed.
+    start()
   }
 
-  var needsMonitoring: Bool {
-    window?.windowScene?.activationState == .foregroundActive &&
-      enabled && status == .available && !suppressed && lastError == nil
-  }
-
-  func updatePresentation() {
+  private func start() {
+    guard observation == nil, enabled, let tip, let window,
+          !bounds.isEmpty, let parent = parentViewController,
+          parent.viewIfLoaded?.window === window else { return }
     let runtime = TinyuiTipsRuntime.shared
-    guard let tip else { dismissTip(); return }
-    guard window != nil, runtime.isConfigured else {
-      if window != nil && enabled && !runtime.isConfigured {
-        reportError("E_TIPS_NOT_CONFIGURED", "Call and await TipKit.configure() before displaying tips.")
-      }
-      dismissTip()
+    guard runtime.isConfigured else {
+      reportError("E_TIPS_NOT_CONFIGURED", "Call and await TipKit.configure() before displaying tips.")
       return
     }
     do {
@@ -96,25 +83,38 @@ import UIKit
     } catch {
       let error = error as NSError
       reportError(error.userInfo["code"] as? String ?? "E_TIP", error.localizedDescription)
-      dismissTip()
       return
     }
-    startObservation(tip)
 
+    observation = Task { @MainActor [weak self] in
+      for await shouldDisplay in tip.shouldDisplayUpdates {
+        guard !Task.isCancelled, let self else { break }
+        self.shouldDisplay = shouldDisplay
+        self.updatePresentation()
+      }
+    }
+  }
+
+  private func stop() {
+    observation?.cancel()
+    observation = nil
+    shouldDisplay = false
+    dismissTip()
+  }
+
+  private func updatePresentation() {
     if let controller, !isPresenting, !isDismissing, controller.presentingViewController == nil {
       // Dismissal may originate inside TipKit rather than through the delegate.
-      suppressed = true
       finishDismissal(controller)
       return
     }
-    let presenter = eligiblePresenter()
-    guard enabled, status == .available, !suppressed, presenter != nil,
+    guard enabled, window != nil, let tip, shouldDisplay,
           presentedTipId == nil || presentedTipId == tip.id else {
       dismissTip()
       return
     }
-    guard controller == nil, runtime.activeProvider == nil, let presenter else { return }
-    runtime.activeProvider = self
+    // Like Tipster's TipPresenter, only present when the host is free.
+    guard controller == nil, let presenter = availablePresenter() else { return }
     let tipController = TipUIPopoverViewController(tip, sourceItem: self) { [weak self] action in
       guard let self, self.tip?.id == tip.id,
             let content = tip.actionContents.first(where: { $0.id == action.id }) else { return }
@@ -125,84 +125,22 @@ import UIKit
     presentedTipId = tip.id
     configureArrow()
     isPresenting = true
-    presenter.present(tipController, animated: true) { [weak self, weak tipController] in
-      guard let self, let tipController, self.controller === tipController else { return }
+    // Retain the provider through the animation so a Fabric unmount can still
+    // dismiss this presentation in the completion, without a global owner.
+    presenter.present(tipController, animated: true) { [self] in
+      guard self.controller === tipController else { return }
       self.isPresenting = false
-      if tipController.presentingViewController != nil {
-        self.reportedVisible = true
-        self.delegate?.onTipVisible(tipId: tip.id, visible: true)
-      }
-      TinyuiTipsRuntime.shared.requestUpdate()
-    }
-  }
-
-  private func startObservation(_ tip: TinyuiTip) {
-    guard observation == nil else { return }
-    observationGeneration += 1
-    let generation = observationGeneration
-    observation = Task { @MainActor [weak self] in
-      for await status in tip.statusUpdates {
-        guard !Task.isCancelled, let self, self.observationGeneration == generation else { break }
-        self.status = status
-        let state: String
-        let reason: String
-        switch status {
-        case .pending: state = "pending"; reason = ""
-        case .available: state = "available"; reason = ""
-        case .invalidated(let invalidation):
-          state = "invalidated"
-          switch invalidation {
-          case .actionPerformed: reason = "actionPerformed"
-          case .tipClosed: reason = "tipClosed"
-          case .displayCountExceeded: reason = "displayCountExceeded"
-          case .displayDurationExceeded: reason = "displayDurationExceeded"
-          @unknown default: reason = "unknown"
-          }
-        @unknown default: state = "pending"; reason = ""
-        }
-        self.delegate?.onTipStatus(tipId: tip.id, status: state, reason: reason)
-        TinyuiTipsRuntime.shared.requestUpdate()
-      }
+      self.updatePresentation()
     }
   }
 
-  private func stopObservation() {
-    observationGeneration += 1
-    observation?.cancel()
-    observation = nil
-    status = nil
-  }
-
-  /// Reject obscured/detached anchors and non-current navigation/tab screens.
-  private func eligiblePresenter() -> UIViewController? {
-    guard let window, window.windowScene?.activationState == .foregroundActive,
-          !window.isHidden, let parent = parentViewController,
-          parent.viewIfLoaded?.window === window, !bounds.isEmpty else { return nil }
-
-    var visibleRect = convert(bounds, to: window)
-    var ancestor: UIView? = self
-    while let view = ancestor {
-      guard !view.isHidden, view.alpha > 0.01 else { return nil }
-      if view.clipsToBounds {
-        visibleRect = visibleRect.intersection(view.convert(view.bounds, to: window))
-      }
-      ancestor = view.superview
-    }
-    guard !visibleRect.intersection(window.bounds).isEmpty else { return nil }
-
-    var child = parent
+  private func availablePresenter() -> UIViewController? {
+    guard let window, let parent = parentViewController,
+          parent.viewIfLoaded?.window === window else { return nil }
     var ancestorController: UIViewController? = parent
     while let current = ancestorController {
-      guard !current.isBeingDismissed, !current.isBeingPresented else { return nil }
-      if let navigation = current as? UINavigationController,
-         navigation.topViewController !== child { return nil }
-      if let tabs = current as? UITabBarController,
-         tabs.selectedViewController !== child { return nil }
-      if let presented = current.presentedViewController, presented !== controller { return nil }
-      // Wait for navigation animations before presenting. Do not treat our own
-      // popover's presentation transition as the anchor leaving the screen.
-      if controller == nil && current.transitionCoordinator != nil { return nil }
-      child = current
+      guard !current.isBeingDismissed, !current.isBeingPresented,
+            current.presentedViewController == nil else { return nil }
       ancestorController = current.parent
     }
     return parent
@@ -226,28 +164,24 @@ import UIKit
     guard let controller, !isPresenting, !isDismissing else { return }
     guard controller.presentingViewController != nil else { finishDismissal(controller); return }
     isDismissing = true
-    controller.dismiss(animated: window != nil) { [weak self, weak controller] in
-      guard let self, let controller else { return }
+    controller.dismiss(animated: window != nil) { [self] in
+      guard self.controller === controller else { return }
       self.finishDismissal(controller)
+      // Props may have changed while the dismissal animation was running.
+      self.updatePresentation()
     }
   }
 
   private func finishDismissal(_ dismissed: TipUIPopoverViewController) {
     guard controller === dismissed else { return }
-    if reportedVisible, let presentedTipId {
-      delegate?.onTipVisible(tipId: presentedTipId, visible: false)
-    }
     controller = nil
     presentedTipId = nil
     isPresenting = false
     isDismissing = false
-    reportedVisible = false
-    TinyuiTipsRuntime.shared.release(self)
   }
 
   public func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
     guard let controller, presentationController.presentedViewController === controller else { return }
-    suppressed = true
     finishDismissal(controller)
   }
 
@@ -264,12 +198,9 @@ import UIKit
   @objc public func reset() {
     enabled = false
     tip = nil
-    suppressed = false
     lastError = nil
-    stopObservation()
-    dismissTip()
+    stop()
     parentViewController = nil
-    TinyuiTipsRuntime.shared.unregister(self)
   }
 
   deinit { observation?.cancel() }