react-native-tinyui 2.0.0 → 3.1.0

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() }

package/ios/TipKit/TinyuiTipPopoverView.mm

@@ -69,24 +69,6 @@ using namespace facebook::react;
   [super updateProps:props oldProps:oldProps];
 }
 
-- (void)onTipStatusWithTipId:(NSString *)tipId status:(NSString *)status reason:(NSString *)reason
-{
-  if (_eventEmitter == nullptr) return;
-  std::static_pointer_cast<const TinyuiTipPopoverViewEventEmitter>(_eventEmitter)->onTipStatusChange({
-    .tipId = std::string(tipId.UTF8String ?: ""),
-    .status = std::string(status.UTF8String ?: ""),
-    .reason = std::string(reason.UTF8String ?: ""),
-  });
-}
-
-- (void)onTipVisibleWithTipId:(NSString *)tipId visible:(BOOL)visible
-{
-  if (_eventEmitter == nullptr) return;
-  std::static_pointer_cast<const TinyuiTipPopoverViewEventEmitter>(_eventEmitter)->onTipVisibleChange({
-    .tipId = std::string(tipId.UTF8String ?: ""), .visible = static_cast<bool>(visible),
-  });
-}
-
 - (void)onTipActionWithTipId:(NSString *)tipId id:(NSString *)identifier title:(NSString *)title
 {
   if (_eventEmitter == nullptr) return;

package/ios/TipKit/TinyuiTipView.h

@@ -0,0 +1,8 @@
+#if TINYUI_FEATURE_TIP_KIT
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+@interface TinyuiTipView : RCTViewComponentView
+@end
+NS_ASSUME_NONNULL_END
+#endif

package/ios/TipKit/TinyuiTipView.mm

@@ -0,0 +1,93 @@
+#if TINYUI_FEATURE_TIP_KIT
+#import "TinyuiTipView.h"
+#import "TinyuiTipViewShadowNode.h"
+#import "Tinyui-Swift.h"
+#import <React/RCTConversions.h>
+#import <react/renderer/components/TinyuiSpec/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+@interface TinyuiTipView () <RCTTinyuiTipViewViewProtocol, TinyuiTipViewDelegate>
+@end
+
+@implementation TinyuiTipView {
+  TinyuiTipViewProvider *_provider;
+  TinyuiInlineTipShadowNode::ConcreteState::Shared _state;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<TinyuiInlineTipComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = TinyuiInlineTipShadowNode::defaultSharedProps();
+    _provider = [[TinyuiTipViewProvider alloc] initWithDelegate:self];
+    self.contentView = _provider;
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &next = *std::static_pointer_cast<const TinyuiTipViewProps>(props);
+  NSMutableArray *actions = [NSMutableArray new];
+  for (const auto &action : next.actions) {
+    [actions addObject:@{@"id": RCTNSStringFromString(action.id), @"title": RCTNSStringFromString(action.title)}];
+  }
+  [_provider configure:@{
+    @"tipId": RCTNSStringFromString(next.tipId),
+    @"title": RCTNSStringFromString(next.title),
+    @"message": RCTNSStringFromString(next.message),
+    @"systemImage": RCTNSStringFromString(next.systemImage),
+    @"actions": actions,
+    @"maxDisplayCount": @(next.maxDisplayCount),
+    @"ignoresDisplayFrequency": @(next.ignoresDisplayFrequency),
+  } enabled:next.enabled arrowEdge:RCTNSStringFromString(next.arrowEdge)];
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState
+{
+  _state = std::static_pointer_cast<const TinyuiInlineTipShadowNode::ConcreteState>(state);
+  [_provider setNeedsLayout];
+}
+
+- (void)onTipSizeChangeWithTipId:(NSString *)tipId width:(CGFloat)width height:(CGFloat)height
+{
+  if (_state == nullptr) return;
+  const auto &previous = _state->getData();
+  std::string identifier(tipId.UTF8String ?: "");
+  facebook::react::Size size{static_cast<Float>(width), static_cast<Float>(height)};
+  if (previous.tipId == identifier && previous.contentSize == size) return;
+  _state->updateState(TinyuiInlineTipState{identifier, size});
+}
+
+- (void)onTipActionWithTipId:(NSString *)tipId id:(NSString *)identifier title:(NSString *)title
+{
+  if (_eventEmitter == nullptr) return;
+  std::static_pointer_cast<const TinyuiTipViewEventEmitter>(_eventEmitter)->onTipAction({
+    .tipId = std::string(tipId.UTF8String ?: ""),
+    .id = std::string(identifier.UTF8String ?: ""), .title = std::string(title.UTF8String ?: ""),
+  });
+}
+
+- (void)onTipErrorWithTipId:(NSString *)tipId code:(NSString *)code message:(NSString *)message
+{
+  if (_eventEmitter == nullptr) return;
+  std::static_pointer_cast<const TinyuiTipViewEventEmitter>(_eventEmitter)->onTipError({
+    .tipId = std::string(tipId.UTF8String ?: ""),
+    .code = std::string(code.UTF8String ?: ""), .message = std::string(message.UTF8String ?: ""),
+  });
+}
+
+- (void)prepareForRecycle
+{
+  _state.reset();
+  [_provider reset];
+  [super prepareForRecycle];
+}
+@end
+#endif

package/ios/TipKit/TinyuiTipViewProvider.swift

@@ -0,0 +1,140 @@
+import SwiftUI
+import TipKit
+import UIKit
+
+@objc public protocol TinyuiTipViewDelegate: AnyObject {
+  func onTipAction(tipId: String, id: String, title: String)
+  func onTipError(tipId: String, code: String, message: String)
+  // Fabric consumes this size directly; it is not a JavaScript event.
+  func onTipSizeChange(tipId: String, width: CGFloat, height: CGFloat)
+}
+
+@MainActor
+@objc public final class TinyuiTipViewProvider: UIView {
+  private weak var delegate: TinyuiTipViewDelegate?
+  private var tip: TinyuiTip?
+  private var enabled = false
+  private var arrowEdge: Edge?
+  private var observation: Task<Void, Never>?
+  private var tipView: TipUIView?
+  private var lastError: String?
+
+  @objc public convenience init(delegate: TinyuiTipViewDelegate) {
+    self.init(frame: .zero)
+    self.delegate = delegate
+    clipsToBounds = true
+    registerForTraitChanges([UITraitPreferredContentSizeCategory.self]) { (view: TinyuiTipViewProvider, _: UITraitCollection) in
+      view.setNeedsLayout()
+    }
+  }
+
+  @objc public func configure(_ configuration: [String: Any], enabled: Bool, arrowEdge: String) {
+    let nextTip = TinyuiTip(configuration: configuration)
+    if tip?.id != nextTip.id || self.enabled != enabled {
+      stop()
+      lastError = nil
+    }
+    tip = nextTip
+    self.enabled = enabled
+    switch arrowEdge {
+    case "top": self.arrowEdge = .top
+    case "bottom": self.arrowEdge = .bottom
+    case "leading": self.arrowEdge = .leading
+    case "trailing": self.arrowEdge = .trailing
+    default: self.arrowEdge = nil
+    }
+    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
+    start()
+  }
+
+  override public func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window == nil { stop() } else { start() }
+  }
+
+  private func start() {
+    // A zero initial height is expected: the native view supplies its measured
+    // height to Fabric after the eligibility stream yields its first value.
+    guard observation == nil, enabled, let tip, window != nil else { return }
+    guard TinyuiTipsRuntime.shared.isConfigured else {
+      reportError("E_TIPS_NOT_CONFIGURED", "Call and await TipKit.configure() before displaying tips.")
+      return
+    }
+    observation = Task { @MainActor [weak self] in
+      for await shouldDisplay in tip.shouldDisplayUpdates {
+        guard !Task.isCancelled, let self else { break }
+        if shouldDisplay { self.showTip() } else { self.removeTip() }
+      }
+    }
+  }
+
+  private func showTip() {
+    guard tipView == nil, enabled, window != nil, let tip else { return }
+    let view = TipUIView(tip, arrowEdge: arrowEdge) { [weak self] action in
+      guard let self, self.tip?.id == tip.id,
+            let content = tip.actionContents.first(where: { $0.id == action.id }) else { return }
+      self.delegate?.onTipAction(tipId: tip.id, id: content.id, title: content.title)
+    }
+    tipView = view
+    addSubview(view)
+    setNeedsLayout()
+  }
+
+  private func removeTip() {
+    tipView?.removeFromSuperview()
+    tipView = nil
+    reportSize(height: 0)
+  }
+
+  private func stop() {
+    observation?.cancel()
+    observation = nil
+    removeTip()
+  }
+
+  override public func layoutSubviews() {
+    super.layoutSubviews()
+    guard let tipView else { reportSize(height: 0); return }
+    guard bounds.width > 0 else { return }
+    // TipUIView may cap its card width on iPad. Measure and lay it out at the
+    // same width so a wider proposal cannot underestimate wrapped text height.
+    let intrinsicSize = tipView.intrinsicContentSize
+    let width = intrinsicSize.width.isFinite && intrinsicSize.width > 0
+      ? min(bounds.width, intrinsicSize.width) : bounds.width
+    let fittingSize = tipView.sizeThatFits(CGSize(width: width, height: .greatestFiniteMagnitude))
+    guard fittingSize.height.isFinite else { return }
+    let scale = traitCollection.displayScale > 0 ? traitCollection.displayScale : 1
+    let height = ceil(max(0, fittingSize.height) * scale) / scale
+    let x = effectiveUserInterfaceLayoutDirection == .rightToLeft ? bounds.width - width : 0
+    tipView.frame = CGRect(x: x, y: 0, width: width, height: height)
+    reportSize(height: height)
+  }
+
+  private func reportSize(height: CGFloat) {
+    delegate?.onTipSizeChange(tipId: tip?.id ?? "", width: bounds.width, height: height)
+  }
+
+  private func reportError(_ code: String, _ message: String) {
+    guard lastError != code else { return }
+    lastError = code
+    delegate?.onTipError(tipId: tip?.id ?? "", code: code, message: message)
+  }
+
+  @objc public func reset() {
+    stop()
+    tip = nil
+    enabled = false
+    arrowEdge = nil
+    lastError = nil
+  }
+
+  deinit { observation?.cancel() }
+}

package/ios/TipKit/TinyuiTipViewShadowNode.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <react/renderer/components/TinyuiSpec/ShadowNodes.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <cmath>
+#include <string>
+
+namespace facebook::react {
+
+struct TinyuiInlineTipState final {
+  std::string tipId{};
+  Size contentSize{};
+};
+
+class TinyuiInlineTipShadowNode final
+    : public ConcreteViewShadowNode<
+          TinyuiTipViewComponentName,
+          TinyuiTipViewProps,
+          TinyuiTipViewEventEmitter,
+          TinyuiInlineTipState> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  static ShadowNodeTraits BaseTraits()
+  {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  Size measureContent(const LayoutContext &, const LayoutConstraints &constraints) const override
+  {
+    const auto &props = getConcreteProps();
+    const auto &state = getStateData();
+    // Fill the available width, then let TipUIView measure wrapping on the main
+    // thread. Fabric state brings its height back without a JS layout roundtrip.
+    auto width = std::isfinite(constraints.maximumSize.width)
+        ? constraints.maximumSize.width : state.contentSize.width;
+    auto height = props.enabled && props.tipId == state.tipId ? state.contentSize.height : 0;
+    return constraints.clamp({width, height});
+  }
+};
+
+using TinyuiInlineTipComponentDescriptor = ConcreteComponentDescriptor<TinyuiInlineTipShadowNode>;
+
+} // namespace facebook::react