react-native-platform-components 1.4.0 → 1.6.0

package/ios/PCDatePickerView.swift

@@ -12,6 +12,7 @@ public final class PCDatePickerView: UIControl,
     private let picker = UIDatePicker()
     private var modalVC: UIViewController?
     private var inlineConstraints: [NSLayoutConstraint] = []
+    private var updatingPresentation = false
 
     private var modalToolbarHeight: CGFloat {
         // iOS 26 renders bar button items as oversized Liquid Glass pills;
@@ -31,12 +32,14 @@ public final class PCDatePickerView: UIControl,
     }
 
     // MARK: - Events (wired from ObjC++)
-    public var onChangeHandler: ((NSNumber, Bool) -> Void)?
+    /// (timestampMs, confirmed, durationSeconds). `durationSeconds` is the
+    /// selected countdown duration in countDownTimer mode, 0 otherwise.
+    public var onChangeHandler: ((NSNumber, Bool, NSNumber) -> Void)?
     public var onCancelHandler: (() -> Void)?
 
     // MARK: - Props
 
-    /// "date" | "time" | "dateAndTime" | "countDownTimer"
+    /// "date" | "time" | "dateAndTime" | "countDownTimer" | "yearAndMonth"
     public var mode: String = "date" {
         didSet {
             if oldValue != mode {
@@ -49,7 +52,7 @@ public final class PCDatePickerView: UIControl,
     /// "modal" | "inline"
     public var presentation: String = "modal" {
         didSet {
-            if oldValue != presentation {
+            if oldValue != presentation && !updatingPresentation {
                 applyPresentation()
                 invalidateSize()
             }
@@ -59,7 +62,7 @@ public final class PCDatePickerView: UIControl,
     /// modal only: NSNumber(0/1)
     public var open: NSNumber? {
         didSet {
-            guard oldValue != open else { return }
+            guard oldValue != open, !updatingPresentation else { return }
             applyOpen()
         }
     }
@@ -74,6 +77,16 @@ public final class PCDatePickerView: UIControl,
     public var localeIdentifier: String? { didSet { applyLocale() } }
     public var timeZoneName: String? { didSet { applyTimeZone() } }
 
+    /// "" (the locale's own clock) | "12" | "24"
+    public var hourFormat: String = "" {
+        didSet {
+            if oldValue != hourFormat {
+                applyLocale()
+                invalidateSize()
+            }
+        }
+    }
+
     /// "wheels" | "compact" | "inline" | "automatic"
     public var preferredStyle: String? {
         didSet {
@@ -221,6 +234,28 @@ public final class PCDatePickerView: UIControl,
 
     // MARK: - Presentation
 
+    /// Apply presentation and visibility together after the other props, so
+    /// opening never uses the previous mode, style or toolbar configuration.
+    @objc(configurePresentation:open:)
+    public func configurePresentation(_ value: String, open shouldOpen: Bool) {
+        guard presentation != value || open?.boolValue != shouldOpen else { return }
+        updatingPresentation = true
+        presentation = value
+        open = NSNumber(value: shouldOpen)
+        updatingPresentation = false
+        applyPresentation()
+        invalidateSize()
+    }
+
+    public override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window == nil {
+            dismissIfNeeded(emitCancel: false, animated: false)
+        } else {
+            applyOpen()
+        }
+    }
+
     private func applyPresentation() {
         if presentation == "embedded" {
             dismissIfNeeded(emitCancel: false)
@@ -280,7 +315,7 @@ public final class PCDatePickerView: UIControl,
     // MARK: - Modal Popover
 
     private func presentIfNeeded() {
-        guard modalVC == nil else { return }
+        guard modalVC == nil, window != nil else { return }
         guard let top = topViewController() else {
             logger.warning("presentIfNeeded: no view controller found")
             return
@@ -393,11 +428,11 @@ public final class PCDatePickerView: UIControl,
         top.present(vc, animated: true)
     }
 
-    private func dismissIfNeeded(emitCancel: Bool) {
+    private func dismissIfNeeded(emitCancel: Bool, animated: Bool = true) {
         guard let vc = modalVC else { return }
         logger.debug("dismissIfNeeded: dismissing modal, emitCancel=\(emitCancel)")
         modalVC = nil
-        vc.dismiss(animated: true) { [weak self] in
+        vc.dismiss(animated: animated) { [weak self] in
             guard let self else { return }
             if emitCancel { self.onCancelHandler?() }
         }
@@ -430,21 +465,28 @@ public final class PCDatePickerView: UIControl,
         // Skip "programmatic/settle" changes
         if suppressChangeEvents { return }
 
-        let ms = picker.date.timeIntervalSince1970 * 1000.0
         // In modal mode, valueChanged is "user is still adjusting" —
         // confirmation only happens when the user taps Done. Embedded
         // presentation always confirms (there's no Done button to gate on).
         let isModal = presentation == "modal" && modalVC != nil
-        onChangeHandler?(NSNumber(value: ms), !isModal)
+        emitChange(confirmed: !isModal)
     }
 
     @objc private func handleDoneTap() {
         guard presentation == "modal", modalVC != nil else { return }
-        let ms = picker.date.timeIntervalSince1970 * 1000.0
-        onChangeHandler?(NSNumber(value: ms), true)
+        emitChange(confirmed: true)
         dismissIfNeeded(emitCancel: false)
     }
 
+    /// In countDownTimer mode `picker.date` is meaningless for the caller;
+    /// the selection is `countDownDuration`, reported as `durationSeconds`.
+    private func emitChange(confirmed: Bool) {
+        let ms = picker.date.timeIntervalSince1970 * 1000.0
+        let duration =
+            picker.datePickerMode == .countDownTimer ? picker.countDownDuration : 0
+        onChangeHandler?(NSNumber(value: ms), confirmed, NSNumber(value: duration))
+    }
+
     @objc private func handleCancelTap() {
         dismissIfNeeded(emitCancel: true)
     }
@@ -480,11 +522,29 @@ public final class PCDatePickerView: UIControl,
 
     private func applyLocale() {
         suppressNextChangesBriefly()
+        var locale: Locale?
         if let id = localeIdentifier, !id.isEmpty {
-            picker.locale = Locale(identifier: id)
-        } else {
-            picker.locale = nil
+            locale = Locale(identifier: id)
+        }
+        // UIDatePicker draws its clock in its locale's hour cycle, so a
+        // forced 12/24-hour clock is the locale with that cycle
+        if hourFormat == "12" || hourFormat == "24" {
+            locale = PCDatePickerView.locale(locale ?? .current, is24Hour: hourFormat == "24")
         }
+        picker.locale = locale
+    }
+
+    /// [base] with its hour cycle forced to 0–23 or 1–12.
+    private static func locale(_ base: Locale, is24Hour: Bool) -> Locale {
+        if #available(iOS 16.0, *) {
+            var components = Locale.Components(locale: base)
+            components.hourCycle = is24Hour ? .zeroToTwentyThree : .oneToTwelve
+            return Locale(components: components)
+        }
+        // The ICU keyword that Locale.Components writes on iOS 16+
+        let keyword = "hours=\(is24Hour ? "h23" : "h12")"
+        let id = base.identifier
+        return Locale(identifier: id.contains("@") ? "\(id);\(keyword)" : "\(id)@\(keyword)")
     }
 
     private func applyTimeZone() {
@@ -496,21 +556,39 @@ public final class PCDatePickerView: UIControl,
         }
     }
 
+    /// The countdown timer and the month-and-year picker only exist as wheels
+    private var wheelsOnlyMode: Bool { mode == "countDownTimer" || mode == "yearAndMonth" }
+
     private func applyMode() {
         suppressNextChangesBriefly()
+        // UIKit throws when a wheels-only mode meets the compact or inline
+        // style; set the style it supports first
+        if wheelsOnlyMode { applyPreferredStyle() }
         switch mode {
         case "date": picker.datePickerMode = .date
         case "time": picker.datePickerMode = .time
         case "dateAndTime": picker.datePickerMode = .dateAndTime
         case "countDownTimer": picker.datePickerMode = .countDownTimer
+        case "yearAndMonth":
+            // iOS 17.4; the date wheels before
+            if #available(iOS 17.4, *) {
+                picker.datePickerMode = .yearAndMonth
+            } else {
+                picker.datePickerMode = .date
+            }
         default: picker.datePickerMode = .date
         }
+        // Leaving a wheels-only mode, the preferred style can apply again
+        if !wheelsOnlyMode { applyPreferredStyle() }
+        // countDownDuration is ignored outside countDownTimer mode, so apply it
+        // again in case the prop arrived before the mode did.
+        applyCountDownDuration()
     }
 
     private func applyPreferredStyle() {
         guard #available(iOS 13.4, *) else { return }
         suppressNextChangesBriefly()
-        let s = preferredStyle ?? "automatic"
+        let s = wheelsOnlyMode ? "wheels" : (preferredStyle ?? "automatic")
         switch s {
         case "wheels": picker.preferredDatePickerStyle = .wheels
         case "compact": picker.preferredDatePickerStyle = .compact
@@ -546,11 +624,7 @@ public final class PCDatePickerView: UIControl,
     // MARK: - Top VC (same approach you were using)
 
     private func topViewController() -> UIViewController? {
-        guard
-            let scene = UIApplication.shared.connectedScenes.compactMap({ $0 as? UIWindowScene })
-                .first,
-            let root = scene.windows.first(where: { $0.isKeyWindow })?.rootViewController
-        else { return nil }
+        guard let root = window?.rootViewController else { return nil }
 
         var top = root
         while true {

package/ios/PCFloatingActionButton.h

@@ -0,0 +1,10 @@
+// PCFloatingActionButton.h
+
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface PCFloatingActionButton : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/PCFloatingActionButton.mm

@@ -0,0 +1,177 @@
+// PCFloatingActionButton.mm
+
+#import "PCFloatingActionButton.h"
+
+#import <React/RCTComponentViewFactory.h>
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/PlatformComponentsViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/PlatformComponentsViewSpec/EventEmitters.h>
+#import <react/renderer/components/PlatformComponentsViewSpec/Props.h>
+#import <react/renderer/core/LayoutPrimitives.h>
+
+#if __has_include(<PlatformComponents/PlatformComponents-Swift.h>)
+#import <PlatformComponents/PlatformComponents-Swift.h>
+#else
+#import "PlatformComponents-Swift.h"
+#endif
+
+#import "PCFloatingActionButtonComponentDescriptors-custom.h"
+#import "PCFloatingActionButtonShadowNode-custom.h"
+#import "PCFloatingActionButtonState-custom.h"
+
+using namespace facebook::react;
+
+namespace {
+static inline NSString *NSStringFromStd(const std::string &s, NSString *fallback) {
+  return s.empty() ? fallback : [NSString stringWithUTF8String:s.c_str()];
+}
+
+static inline bool IconEqual(
+    const PCFloatingActionButtonIconStruct &a,
+    const PCFloatingActionButtonIconStruct &b) {
+  return a.iconType == b.iconType && a.iconName == b.iconName && a.iconRequest == b.iconRequest && a.iconUri == b.iconUri &&
+         a.iconScale == b.iconScale && a.iconTinted == b.iconTinted;
+}
+} // namespace
+
+@interface PCFloatingActionButton ()
+
+- (void)updateMeasurements;
+
+@end
+
+@implementation PCFloatingActionButton {
+  PCFloatingActionButtonView *_view;
+  MeasuringPCFloatingActionButtonShadowNode::ConcreteState::Shared _state;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<MeasuringPCFloatingActionButtonComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    // Fabric views seed _props with their own defaults: RCTViewComponentView
+    // asserts on it in debug builds of React Native core, and the first
+    // updateProps would otherwise read the base ViewProps as the component's.
+    static const auto defaultProps = std::make_shared<const PCFloatingActionButtonProps>();
+    _props = defaultProps;
+
+    _view = [PCFloatingActionButtonView new];
+    self.contentView = _view;
+
+    __weak __typeof(self) weakSelf = self;
+
+    _view.onPress = ^{
+      __typeof(self) strongSelf = weakSelf;
+      if (!strongSelf) return;
+
+      [strongSelf->_view.haptics performIn:strongSelf->_view];
+
+      auto eventEmitter = std::static_pointer_cast<const PCFloatingActionButtonEventEmitter>(
+          strongSelf->_eventEmitter);
+      if (!eventEmitter) return;
+
+      eventEmitter->onFabPress({});
+    };
+
+    _view.onNeedsRemeasure = ^{
+      __typeof(self) strongSelf = weakSelf;
+      if (!strongSelf) return;
+      [strongSelf updateMeasurements];
+    };
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  const auto &newProps = *std::static_pointer_cast<const PCFloatingActionButtonProps>(props);
+  const auto prevProps = std::static_pointer_cast<const PCFloatingActionButtonProps>(oldProps);
+
+  // icon: {iconType, iconName, iconUri, iconScale, iconTinted}
+  if (!prevProps || !IconEqual(newProps.icon, prevProps->icon)) {
+    const auto &icon = newProps.icon;
+    [_view setIconWithType:NSStringFromStd(icon.iconType, @"")
+                      name:NSStringFromStd(icon.iconName, @"")
+                       request:NSStringFromStd(icon.iconRequest, @"")
+                       uri:NSStringFromStd(icon.iconUri, @"")
+                     scale:icon.iconScale
+                    tinted:(icon.iconTinted != "false")];
+  }
+
+  if (!prevProps || newProps.size != prevProps->size) {
+    _view.size = NSStringFromStd(newProps.size, @"regular");
+  }
+
+  // extended before the label, which shows in the state it gives
+  if (!prevProps || newProps.extended != prevProps->extended) {
+    _view.extended = newProps.extended != "false";
+  }
+
+  if (!prevProps || newProps.label != prevProps->label) {
+    _view.label = NSStringFromStd(newProps.label, @"");
+  }
+
+  // Colors arrive as SharedColor (already processed by React Native)
+  if (!prevProps || newProps.color != prevProps->color) {
+    _view.containerColor = RCTUIColorFromSharedColor(newProps.color);
+  }
+
+  if (!prevProps || newProps.foregroundColor != prevProps->foregroundColor) {
+    _view.foregroundColor = RCTUIColorFromSharedColor(newProps.foregroundColor);
+  }
+
+  if (!prevProps || newProps.interactivity != prevProps->interactivity) {
+    _view.interactivity = NSStringFromStd(newProps.interactivity, @"enabled");
+  }
+
+  if (!prevProps || newProps.spokenLabel != prevProps->spokenLabel) {
+    _view.spokenLabel = NSStringFromStd(newProps.spokenLabel, @"");
+  }
+
+  if (!prevProps || newProps.scrollViewNativeID != prevProps->scrollViewNativeID) {
+    _view.scrollViewNativeID = NSStringFromStd(newProps.scrollViewNativeID, @"");
+  }
+
+  if (!prevProps || newProps.haptics != prevProps->haptics) {
+    _view.haptics.kind = NSStringFromStd(newProps.haptics, @"");
+  }
+
+  [super updateProps:props oldProps:oldProps];
+
+  [self updateMeasurements];
+}
+
+#pragma mark - State (Measuring)
+
+- (void)updateState:(const State::Shared &)state
+           oldState:(const State::Shared &)oldState {
+  _state = std::static_pointer_cast<const MeasuringPCFloatingActionButtonShadowNode::ConcreteState>(state);
+
+  if (oldState == nullptr) {
+    [self updateMeasurements];
+  }
+
+  [super updateState:state oldState:oldState];
+}
+
+- (void)updateMeasurements {
+  if (_state == nullptr) return;
+
+  CGSize size = [_view sizeForLayoutWithConstrainedTo:CGSizeZero];
+
+  PCFloatingActionButtonStateFrameSize next;
+  next.frameSize = {(Float)size.width, (Float)size.height};
+  if (_state->getData() != next) {
+    _state->updateState(std::move(next));
+  }
+}
+
+@end
+
+Class<RCTComponentViewProtocol> PCFloatingActionButtonCls(void) {
+  return PCFloatingActionButton.class;
+}