react-native-tinyui 0.5.0 → 1.1.0

package/ios/TipKit/TinyuiTipPopoverProvider.swift

@@ -0,0 +1,276 @@
+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)
+}
+
+@MainActor
+@objc public final class TinyuiTipPopoverProvider: UIView, UIPopoverPresentationControllerDelegate {
+  private weak var delegate: TinyuiTipPopoverDelegate?
+  @objc public weak var parentViewController: UIViewController? {
+    didSet { TinyuiTipsRuntime.shared.requestUpdate() }
+  }
+  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 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)
+    self.delegate = delegate
+  }
+
+  @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
+      lastError = nil
+      suppressed = false
+    }
+    if !self.enabled && enabled { suppressed = false }
+    tip = nextTip
+    self.enabled = enabled
+    self.arrowEdge = arrowEdge
+    TinyuiTipsRuntime.shared.requestUpdate()
+  }
+
+  override public func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window == nil {
+      stopObservation()
+      dismissTip()
+      TinyuiTipsRuntime.shared.unregister(self)
+    } else {
+      TinyuiTipsRuntime.shared.register(self)
+    }
+  }
+
+  override public func layoutSubviews() {
+    super.layoutSubviews()
+    configureArrow()
+    TinyuiTipsRuntime.shared.requestUpdate()
+  }
+
+  var needsMonitoring: Bool {
+    window?.windowScene?.activationState == .foregroundActive &&
+      enabled && status == .available && !suppressed && lastError == nil
+  }
+
+  func updatePresentation() {
+    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()
+      return
+    }
+    do {
+      try runtime.remember(tip)
+      lastError = nil
+    } catch {
+      let error = error as NSError
+      reportError(error.userInfo["code"] as? String ?? "E_TIP", error.localizedDescription)
+      dismissTip()
+      return
+    }
+    startObservation(tip)
+
+    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,
+          presentedTipId == nil || presentedTipId == tip.id else {
+      dismissTip()
+      return
+    }
+    guard controller == nil, runtime.activeProvider == nil, let presenter else { return }
+    runtime.activeProvider = self
+    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 }
+      self.delegate?.onTipAction(tipId: tip.id, id: content.id, title: content.title)
+    }
+    tipController.presentationDelegate = self
+    controller = tipController
+    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 }
+      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()
+      }
+    }
+  }
+
+  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
+    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
+      ancestorController = current.parent
+    }
+    return parent
+  }
+
+  private func configureArrow() {
+    guard let popover = controller?.popoverPresentationController else { return }
+    popover.sourceView = self
+    popover.sourceRect = bounds
+    let isRTL = effectiveUserInterfaceLayoutDirection == .rightToLeft
+    switch arrowEdge {
+    case "top": popover.permittedArrowDirections = .up
+    case "bottom": popover.permittedArrowDirections = .down
+    case "leading": popover.permittedArrowDirections = isRTL ? .right : .left
+    case "trailing": popover.permittedArrowDirections = isRTL ? .left : .right
+    default: popover.permittedArrowDirections = .any
+    }
+  }
+
+  private func dismissTip() {
+    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 }
+      self.finishDismissal(controller)
+    }
+  }
+
+  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)
+  }
+
+  public func adaptivePresentationStyle(for controller: UIPresentationController) -> UIModalPresentationStyle { .none }
+
+  public func adaptivePresentationStyle(for controller: UIPresentationController, traitCollection: UITraitCollection) -> UIModalPresentationStyle { .none }
+
+  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() {
+    enabled = false
+    tip = nil
+    suppressed = false
+    lastError = nil
+    stopObservation()
+    dismissTip()
+    parentViewController = nil
+    TinyuiTipsRuntime.shared.unregister(self)
+  }
+
+  deinit { observation?.cancel() }
+}

package/ios/TipKit/TinyuiTipPopoverView.h

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

package/ios/TipKit/TinyuiTipPopoverView.mm

@@ -0,0 +1,114 @@
+#if TINYUI_FEATURE_TIP_KIT
+#import "TinyuiTipPopoverView.h"
+#import <React/RCTConversions.h>
+#import <React/UIView+React.h>
+#import <react/renderer/components/TinyuiSpec/ComponentDescriptors.h>
+#import <react/renderer/components/TinyuiSpec/EventEmitters.h>
+#import <react/renderer/components/TinyuiSpec/Props.h>
+#import <react/renderer/components/TinyuiSpec/RCTComponentViewHelpers.h>
+#import "RCTFabricComponentsPlugins.h"
+#import "Tinyui-Swift.h"
+
+using namespace facebook::react;
+
+@interface TinyuiTipPopoverView () <RCTTinyuiTipPopoverViewViewProtocol, TinyuiTipPopoverDelegate>
+@end
+
+@implementation TinyuiTipPopoverView {
+  TinyuiTipPopoverProvider *_provider;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<TinyuiTipPopoverViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const TinyuiTipPopoverViewProps>();
+    _props = defaultProps;
+    _provider = [[TinyuiTipPopoverProvider alloc] initWithDelegate:self];
+    self.contentView = _provider;
+  }
+  return self;
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  _provider.parentViewController = self.window != nil ? [self reactViewController] : nil;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_provider insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &next = *std::static_pointer_cast<const TinyuiTipPopoverViewProps>(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)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;
+  std::static_pointer_cast<const TinyuiTipPopoverViewEventEmitter>(_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 TinyuiTipPopoverViewEventEmitter>(_eventEmitter)->onTipError({
+    .tipId = std::string(tipId.UTF8String ?: ""),
+    .code = std::string(code.UTF8String ?: ""), .message = std::string(message.UTF8String ?: ""),
+  });
+}
+
+- (void)prepareForRecycle
+{
+  [_provider reset];
+  [super prepareForRecycle];
+}
+@end
+#endif

package/ios/TipKit/TinyuiTipsRuntime.swift

@@ -0,0 +1,148 @@
+import TipKit
+import UIKit
+
+/// Shared across RN surfaces and Fast Refresh. TipKit's datastore owns history.
+@MainActor
+@objc public final class TinyuiTipsRuntime: NSObject {
+  static let shared = TinyuiTipsRuntime()
+
+  private final class WeakProvider {
+    weak var value: TinyuiTipPopoverProvider?
+    init(_ value: TinyuiTipPopoverProvider) { self.value = value }
+  }
+
+  private var frequency: String?
+  private var providers: [WeakProvider] = []
+  private var timer: Timer?
+  private var updateScheduled = false
+  private var knownTips: [String: TinyuiTip] = [:]
+  // Keep an in-flight presentation alive long enough to dismiss it even if
+  // Fabric unmounts/recycles its owning component during the animation.
+  var activeProvider: TinyuiTipPopoverProvider?
+
+  private override init() {
+    super.init()
+    NotificationCenter.default.addObserver(self, selector: #selector(applicationStateChanged), name: UIApplication.didBecomeActiveNotification, object: nil)
+    NotificationCenter.default.addObserver(self, selector: #selector(applicationStateChanged), name: UIApplication.willResignActiveNotification, object: nil)
+  }
+
+  @objc private func applicationStateChanged() { requestUpdate() }
+
+  var isConfigured: Bool { frequency != nil }
+
+  @objc public static func configure(_ frequency: String, completion: (NSError?) -> Void) {
+    do {
+      try shared.configure(frequency)
+      completion(nil)
+    } catch {
+      completion(error as NSError)
+    }
+  }
+
+  @objc public static func invalidate(_ tipId: String, reason: String, completion: (NSError?) -> Void) {
+    guard shared.isConfigured else {
+      completion(error("E_TIPS_NOT_CONFIGURED", "Call and await TipKit.configure() before invalidating a tip."))
+      return
+    }
+    guard !tipId.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+          reason == "actionPerformed" || reason == "tipClosed" else {
+      completion(error("E_INVALID_TIP", "A nonempty tipId and a supported invalidation reason are required."))
+      return
+    }
+    // Tip identity is independent of its view or Swift type. This also works
+    // before the tip mounts, when the feature is discovered without a tip.
+    let tip = shared.knownTips[tipId] ?? TinyuiTip(id: tipId)
+    tip.invalidate(reason: reason == "tipClosed" ? .tipClosed : .actionPerformed)
+    shared.requestUpdate()
+    completion(nil)
+  }
+
+  private func configure(_ frequency: String) throws {
+    if let configuredFrequency = self.frequency {
+      guard configuredFrequency == frequency else {
+        throw Self.error("E_TIPS_ALREADY_CONFIGURED", "TipKit is already configured with a different displayFrequency. Configure it once at app startup.")
+      }
+      return
+    }
+    let nativeFrequency: Tips.ConfigurationOption.DisplayFrequency
+    switch frequency {
+    case "immediate": nativeFrequency = .immediate
+    case "hourly": nativeFrequency = .hourly
+    case "daily": nativeFrequency = .daily
+    case "weekly": nativeFrequency = .weekly
+    case "monthly": nativeFrequency = .monthly
+    default: throw Self.error("E_INVALID_TIPS_CONFIGURATION", "Unsupported displayFrequency.")
+    }
+    try Tips.configure([.displayFrequency(nativeFrequency)])
+    self.frequency = frequency
+    requestUpdate()
+  }
+
+  static func error(_ code: String, _ message: String) -> NSError {
+    NSError(domain: "TinyuiTips", code: 1, userInfo: [
+      NSLocalizedDescriptionKey: message,
+      "code": code,
+    ])
+  }
+
+  func register(_ provider: TinyuiTipPopoverProvider) {
+    providers.removeAll { $0.value == nil }
+    if !providers.contains(where: { $0.value === provider }) {
+      providers.append(WeakProvider(provider))
+    }
+    requestUpdate()
+  }
+
+  func unregister(_ provider: TinyuiTipPopoverProvider) {
+    providers.removeAll { $0.value == nil || $0.value === provider }
+    requestUpdate()
+  }
+
+  func remember(_ tip: TinyuiTip) throws {
+    if let previous = knownTips[tip.id],
+       previous.maximumDisplayCount != tip.maximumDisplayCount || previous.ignoresFrequency != tip.ignoresFrequency {
+      throw Self.error("E_CONFLICTING_TIP_OPTIONS", "maxDisplayCount and ignoresDisplayFrequency must remain consistent for the same tipId.")
+    }
+    knownTips[tip.id] = tip
+  }
+
+  func release(_ provider: TinyuiTipPopoverProvider) {
+    if activeProvider === provider { activeProvider = nil }
+    requestUpdate()
+  }
+
+  func requestUpdate() {
+    guard !updateScheduled else { return }
+    updateScheduled = true
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+      self.updateScheduled = false
+      self.update()
+    }
+  }
+
+  private func update() {
+    providers.removeAll { $0.value == nil }
+    // Finish dismissing an old presentation before offering its slot to another.
+    activeProvider?.updatePresentation()
+    for provider in providers.compactMap(\.value) where provider !== activeProvider {
+      provider.updatePresentation()
+    }
+
+    // UIKit has no single notification for an anchor being scrolled offscreen,
+    // a navigation transition ending, or another modal being dismissed. Poll
+    // only while a tip is eligible/on screen; idle or disabled tips do no work.
+    let needsMonitoring = activeProvider != nil || providers.contains { $0.value?.needsMonitoring == true }
+    if needsMonitoring && timer == nil {
+      let timer = Timer(timeInterval: 0.25, repeats: true) { [weak self] _ in
+        Task { @MainActor [weak self] in self?.update() }
+      }
+      timer.tolerance = 0.05
+      RunLoop.main.add(timer, forMode: .common)
+      self.timer = timer
+    } else if !needsMonitoring {
+      timer?.invalidate()
+      timer = nil
+    }
+  }
+}

package/lib/module/ConcentricView/ConcentricViewNativeComponent.ts

@@ -0,0 +1,14 @@
+import {
+  codegenNativeComponent,
+  type CodegenTypes,
+  type ViewProps,
+} from 'react-native';
+
+export interface NativeConcentricViewProps extends ViewProps {
+  minimumRadius?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+}
+
+export default codegenNativeComponent<NativeConcentricViewProps>(
+  'TinyuiConcentricView',
+  { excludedPlatforms: ['android'] }
+);

package/lib/module/ConcentricView/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import { forwardRef } from 'react';
+import { StyleSheet } from 'react-native';
+import { assertComponentEnabled } from "../utils/index.js";
+import NativeConcentricView from './ConcentricViewNativeComponent';
+import { jsx as _jsx } from "react/jsx-runtime";
+export const ConcentricView = /*#__PURE__*/forwardRef(function ConcentricViewRoot({
+  minimumRadius = 0,
+  style,
+  ...viewProps
+}, ref) {
+  assertComponentEnabled('ConcentricView');
+  if (!Number.isFinite(minimumRadius) || minimumRadius < 0) {
+    throw new RangeError('[TinyUI] ConcentricView minimumRadius must be a finite, nonnegative number.');
+  }
+  return /*#__PURE__*/_jsx(NativeConcentricView, {
+    ...viewProps,
+    ref: ref,
+    minimumRadius: minimumRadius,
+    style: [styles.container, style]
+  });
+});
+const styles = StyleSheet.create({
+  container: {
+    overflow: 'hidden'
+  }
+});
+//# sourceMappingURL=index.js.map

package/lib/module/ConcentricView/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["forwardRef","StyleSheet","assertComponentEnabled","NativeConcentricView","jsx","_jsx","ConcentricView","ConcentricViewRoot","minimumRadius","style","viewProps","ref","Number","isFinite","RangeError","styles","container","create","overflow"],"sourceRoot":"../../../src","sources":["ConcentricView/index.tsx"],"mappings":";;AAAA,SAASA,UAAU,QAA2B,OAAO;AACrD,SAASC,UAAU,QAAmB,cAAc;AAEpD,SAASC,sBAAsB,QAAQ,mBAAU;AACjD,OAAOC,oBAAoB,MAAM,iCAAiC;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAGnE,OAAO,MAAMC,cAAc,gBAAGN,UAAU,CAGtC,SAASO,kBAAkBA,CAAC;EAAEC,aAAa,GAAG,CAAC;EAAEC,KAAK;EAAE,GAAGC;AAAU,CAAC,EAAEC,GAAG,EAAE;EAC7ET,sBAAsB,CAAC,gBAAgB,CAAC;EAExC,IAAI,CAACU,MAAM,CAACC,QAAQ,CAACL,aAAa,CAAC,IAAIA,aAAa,GAAG,CAAC,EAAE;IACxD,MAAM,IAAIM,UAAU,CAClB,6EACF,CAAC;EACH;EAEA,oBACET,IAAA,CAACF,oBAAoB;IAAA,GACfO,SAAS;IACbC,GAAG,EAAEA,GAAI;IACTH,aAAa,EAAEA,aAAc;IAC7BC,KAAK,EAAE,CAACM,MAAM,CAACC,SAAS,EAAEP,KAAK;EAAE,CAClC,CAAC;AAEN,CAAC,CAAC;AAEF,MAAMM,MAAM,GAAGd,UAAU,CAACgB,MAAM,CAAC;EAC/BD,SAAS,EAAE;IAAEE,QAAQ,EAAE;EAAS;AAClC,CAAC,CAAC","ignoreList":[]}

package/lib/module/ConcentricView/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/ConcentricView/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["ConcentricView/types.ts"],"mappings":"","ignoreList":[]}

package/lib/module/Menu/MenuNativeComponent.ts

@@ -1,6 +1,9 @@
+import type * as React from 'react';
 import {
   codegenNativeComponent,
+  codegenNativeCommands,
   type CodegenTypes,
+  type HostComponent,
   type ViewProps,
 } from 'react-native';
 import type { DirectEventHandler } from 'react-native/Libraries/Types/CodegenTypes';
@@ -9,11 +12,17 @@ export interface NativeMenuProps extends ViewProps {
   menuConfig: CodegenTypes.UnsafeMixed;
   title?: string;
   disabled?: boolean;
-  hasPrimaryAction?: boolean;
-  onItemPress?: DirectEventHandler<Readonly<{ id: string }>>;
-  onPrimaryAction?: DirectEventHandler<null>;
+  onActionPress?: DirectEventHandler<Readonly<{ id: string; title: string }>>;
 }
 
+interface NativeCommands {
+  open: (viewRef: React.ComponentRef<HostComponent<NativeMenuProps>>) => void;
+}
+
+export const Commands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['open'],
+});
+
 export default codegenNativeComponent<NativeMenuProps>('TinyuiMenuView', {
   excludedPlatforms: ['android'],
 });