react-native-platform-components 0.6.0 → 0.7.0

package/app.plugin.cjs

@@ -0,0 +1,4 @@
+// Expo config plugin entry point
+// This file is used by Expo to locate the config plugin
+
+module.exports = require('./plugin/build/index.cjs').default;

package/expo-module.config.json

@@ -0,0 +1,4 @@
+{
+  "name": "react-native-platform-components",
+  "platforms": ["ios", "android"]
+}

package/ios/PCContextMenu.swift

@@ -114,6 +114,8 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         }
     }
 
+
+
     private func updateEnabled() {
         let disabled = (interactivity == "disabled")
         alpha = disabled ? 0.5 : 1.0
@@ -146,10 +148,14 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
 
     private func installContextMenuInteraction() {
         guard contextMenuInteraction == nil else { return }
+
+        // Install interaction on self so that long-press on our view triggers the menu.
+        // We use UITargetedPreview in the delegate methods to show the parent view
+        // (which contains the React content) as the preview.
         let interaction = UIContextMenuInteraction(delegate: self)
         addInteraction(interaction)
         contextMenuInteraction = interaction
-        logger.debug("Installed UIContextMenuInteraction")
+        logger.debug("Installed UIContextMenuInteraction on PCContextMenuView")
     }
 
     private func removeContextMenuInteraction() {
@@ -167,14 +173,12 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
             return
         }
 
-        let button = UIButton(type: .custom)
+        let button = UIButton(type: .system)
         button.backgroundColor = .clear
         button.showsMenuAsPrimaryAction = true
         button.translatesAutoresizingMaskIntoConstraints = false
-
-        // Add context menu interaction to track menu lifecycle
-        let interaction = UIContextMenuInteraction(delegate: self)
-        button.addInteraction(interaction)
+        // Make button invisible but still tappable
+        button.tintColor = .clear
 
         addSubview(button)
         NSLayoutConstraint.activate([
@@ -218,25 +222,13 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         let actions = parsedActions.filter { !$0.hidden }
         guard !actions.isEmpty else { return nil }
 
-        logger.debug("contextMenuInteraction: creating configuration with \(actions.count) actions")
+        let actionCountStr = String(actions.count)
+        logger.debug("contextMenuInteraction: creating configuration with \(actionCountStr) actions")
 
+        // Use nil previewProvider - we'll use UITargetedPreview via delegate instead
         return UIContextMenuConfiguration(
             identifier: nil,
-            previewProvider: enablePreview == "true" ? { [weak self] in
-                // Return a preview controller showing the content
-                guard let self else { return nil }
-                let preview = UIViewController()
-                preview.view.backgroundColor = .clear
-
-                // Snapshot the current view for preview
-                let snapshot = self.snapshotView(afterScreenUpdates: false)
-                if let snap = snapshot {
-                    snap.frame = CGRect(origin: .zero, size: self.bounds.size)
-                    preview.view.addSubview(snap)
-                    preview.preferredContentSize = self.bounds.size
-                }
-                return preview
-            } : nil,
+            previewProvider: nil,
             actionProvider: { [weak self] suggestedActions in
                 guard let self else { return nil }
                 return self.buildMenu(from: actions, title: self.menuTitle)
@@ -244,6 +236,57 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         )
     }
 
+    /// Get the parent component view (PCContextMenu) which contains all React content
+    private func getParentComponentView() -> UIView? {
+        return superview
+    }
+
+    public func contextMenuInteraction(
+        _ interaction: UIContextMenuInteraction,
+        previewForHighlightingMenuWithConfiguration configuration: UIContextMenuConfiguration
+    ) -> UITargetedPreview? {
+        let parameters = UIPreviewParameters()
+        parameters.backgroundColor = .clear
+
+        // Check if preview is enabled via the enablePreview prop
+        if enablePreview == "true" {
+            // Target the parent view (PCContextMenu) which contains the React content
+            guard let parentView = getParentComponentView() else {
+                logger.debug("previewForHighlighting: no parent found")
+                return nil
+            }
+            let parentType = String(describing: type(of: parentView))
+            logger.debug("previewForHighlighting: targeting parent \(parentType)")
+            parameters.visiblePath = UIBezierPath(roundedRect: parentView.bounds, cornerRadius: 8)
+            return UITargetedPreview(view: parentView, parameters: parameters)
+        } else {
+            // When preview is disabled, target self with zero-size path
+            // This prevents iOS from manipulating the parent view and causing white flashes
+            logger.debug("previewForHighlighting: preview disabled, targeting self with zero path")
+            parameters.visiblePath = UIBezierPath(rect: .zero)
+            return UITargetedPreview(view: self, parameters: parameters)
+        }
+    }
+
+    public func contextMenuInteraction(
+        _ interaction: UIContextMenuInteraction,
+        previewForDismissingMenuWithConfiguration configuration: UIContextMenuConfiguration
+    ) -> UITargetedPreview? {
+        let parameters = UIPreviewParameters()
+        parameters.backgroundColor = .clear
+
+        if enablePreview == "true" {
+            guard let parentView = getParentComponentView() else {
+                return nil
+            }
+            parameters.visiblePath = UIBezierPath(roundedRect: parentView.bounds, cornerRadius: 8)
+            return UITargetedPreview(view: parentView, parameters: parameters)
+        } else {
+            parameters.visiblePath = UIBezierPath(rect: .zero)
+            return UITargetedPreview(view: self, parameters: parameters)
+        }
+    }
+
     public func contextMenuInteraction(
         _ interaction: UIContextMenuInteraction,
         willDisplayMenuFor configuration: UIContextMenuConfiguration,

package/ios/PCDatePickerView.swift

@@ -284,30 +284,47 @@ public final class PCDatePickerView: UIControl,
         suppressNextChangesBriefly()
 
         let vc = UIViewController()
-        vc.view.backgroundColor = .clear
-        vc.view.isOpaque = false
-
         picker.translatesAutoresizingMaskIntoConstraints = false
         vc.view.addSubview(picker)
 
-        // Position picker at top-leading (constraints required to avoid freeze with inline style)
-        NSLayoutConstraint.activate([
-            picker.topAnchor.constraint(equalTo: vc.view.topAnchor),
-            picker.leadingAnchor.constraint(equalTo: vc.view.leadingAnchor),
-        ])
+        let useInlineFallback: Bool
+        if #available(iOS 26.0, *) {
+            useInlineFallback = false
+        } else {
+            useInlineFallback = true
+        }
+
+        if useInlineFallback {
+            // Pre–Liquid Glass fallback
+            vc.view.backgroundColor = .systemBackground
+            vc.view.isOpaque = true
+
+            NSLayoutConstraint.activate([
+                picker.topAnchor.constraint(equalTo: vc.view.topAnchor),
+                picker.leadingAnchor.constraint(equalTo: vc.view.leadingAnchor),
+                picker.trailingAnchor.constraint(equalTo: vc.view.trailingAnchor),
+                picker.bottomAnchor.constraint(equalTo: vc.view.bottomAnchor),
+            ])
+        } else {
+            // Liquid Glass path
+            vc.view.backgroundColor = .clear
+            vc.view.isOpaque = false
+
+            NSLayoutConstraint.activate([
+                picker.topAnchor.constraint(equalTo: vc.view.topAnchor),
+                picker.leadingAnchor.constraint(equalTo: vc.view.leadingAnchor),
+            ])
+        }
 
         let size = popoverContentSize()
         vc.preferredContentSize = size
 
-        // ✅ Anchored popover-style (not a full sheet)
         vc.modalPresentationStyle = .popover
         vc.presentationController?.delegate = self
 
         if let pop = vc.popoverPresentationController {
             pop.delegate = self
             pop.sourceView = self
-            // Use a minimum height for sourceRect to help popover positioning
-            // (modal presentation views have zero intrinsic height)
             let sourceRect = CGRect(
                 x: bounds.minX,
                 y: bounds.minY,

package/ios/PCSegmentedControl.h

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

package/ios/PCSegmentedControl.mm

@@ -0,0 +1,194 @@
+// PCSegmentedControl.mm
+
+#import "PCSegmentedControl.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 "PCSegmentedControlComponentDescriptors-custom.h"
+#import "PCSegmentedControlShadowNode-custom.h"
+#import "PCSegmentedControlState-custom.h"
+
+using namespace facebook::react;
+
+namespace {
+static inline bool SegmentsEqual(
+    const std::vector<facebook::react::PCSegmentedControlSegmentsStruct> &a,
+    const std::vector<facebook::react::PCSegmentedControlSegmentsStruct> &b) {
+  if (a.size() != b.size()) return false;
+  for (size_t i = 0; i < a.size(); i++) {
+    if (a[i].label != b[i].label) return false;
+    if (a[i].value != b[i].value) return false;
+    if (a[i].disabled != b[i].disabled) return false;
+    if (a[i].icon != b[i].icon) return false;
+  }
+  return true;
+}
+} // namespace
+
+@interface PCSegmentedControl ()
+
+- (void)updateMeasurements;
+
+@end
+
+@implementation PCSegmentedControl {
+  PCSegmentedControlView *_view;
+  MeasuringPCSegmentedControlShadowNode::ConcreteState::Shared _state;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      MeasuringPCSegmentedControlComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _view = [PCSegmentedControlView new];
+    self.contentView = _view;
+
+    __weak __typeof(self) weakSelf = self;
+
+    _view.onSelect = ^(NSInteger index, NSString *value) {
+      __typeof(self) strongSelf = weakSelf;
+      if (!strongSelf) return;
+
+      auto eventEmitter =
+          std::static_pointer_cast<const PCSegmentedControlEventEmitter>(
+              strongSelf->_eventEmitter);
+      if (!eventEmitter) return;
+
+      PCSegmentedControlEventEmitter::OnSelect payload = {
+          .index = (int)index,
+          .value = value.UTF8String,
+      };
+
+      eventEmitter->onSelect(payload);
+    };
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  const auto &newProps =
+      *std::static_pointer_cast<const PCSegmentedControlProps>(props);
+  const auto prevProps =
+      std::static_pointer_cast<const PCSegmentedControlProps>(oldProps);
+
+  // segments: [{label, value, disabled, icon}]
+  if (!prevProps || !SegmentsEqual(newProps.segments, prevProps->segments)) {
+    NSMutableArray *arr = [NSMutableArray new];
+    for (const auto &seg : newProps.segments) {
+      NSString *label = seg.label.empty()
+                            ? @""
+                            : [NSString stringWithUTF8String:seg.label.c_str()];
+      NSString *value = seg.value.empty()
+                            ? @""
+                            : [NSString stringWithUTF8String:seg.value.c_str()];
+      NSString *disabled = seg.disabled.empty()
+                               ? @"enabled"
+                               : [NSString stringWithUTF8String:seg.disabled.c_str()];
+      NSString *icon = seg.icon.empty()
+                           ? @""
+                           : [NSString stringWithUTF8String:seg.icon.c_str()];
+      [arr addObject:@{
+        @"label": label,
+        @"value": value,
+        @"disabled": disabled,
+        @"icon": icon
+      }];
+    }
+    _view.segments = arr;
+  }
+
+  // selectedValue (default "")
+  if (!prevProps || newProps.selectedValue != prevProps->selectedValue) {
+    if (!newProps.selectedValue.empty()) {
+      _view.selectedValue =
+          [NSString stringWithUTF8String:newProps.selectedValue.c_str()];
+    } else {
+      _view.selectedValue = @""; // sentinel for no selection
+    }
+  }
+
+  // interactivity: "enabled" | "disabled"
+  if (!prevProps || newProps.interactivity != prevProps->interactivity) {
+    if (!newProps.interactivity.empty()) {
+      _view.interactivity =
+          [NSString stringWithUTF8String:newProps.interactivity.c_str()];
+    } else {
+      _view.interactivity = @"enabled";
+    }
+  }
+
+  // iOS-specific props
+  const auto &newIos = newProps.ios;
+  const auto &oldIos =
+      prevProps ? prevProps->ios : PCSegmentedControlIosStruct{};
+
+  if (!prevProps || newIos.momentary != oldIos.momentary) {
+    _view.momentary = (newIos.momentary == "true");
+  }
+
+  if (!prevProps || newIos.apportionsSegmentWidthsByContent != oldIos.apportionsSegmentWidthsByContent) {
+    _view.apportionsSegmentWidthsByContent = (newIos.apportionsSegmentWidthsByContent == "true");
+  }
+
+  if (!prevProps || newIos.selectedSegmentTintColor != oldIos.selectedSegmentTintColor) {
+    if (!newIos.selectedSegmentTintColor.empty()) {
+      _view.selectedSegmentTintColor =
+          [NSString stringWithUTF8String:newIos.selectedSegmentTintColor.c_str()];
+    } else {
+      _view.selectedSegmentTintColor = nil;
+    }
+  }
+
+  [super updateProps:props oldProps:oldProps];
+
+  // Update measurements when props change that affect layout
+  [self updateMeasurements];
+}
+
+#pragma mark - State (Measuring)
+
+- (void)updateState:(const State::Shared &)state
+           oldState:(const State::Shared &)oldState {
+  _state = std::static_pointer_cast<
+      const MeasuringPCSegmentedControlShadowNode::ConcreteState>(state);
+
+  if (oldState == nullptr) {
+    // First time: compute initial size.
+    [self updateMeasurements];
+  }
+
+  [super updateState:state oldState:oldState];
+}
+
+- (void)updateMeasurements {
+  if (_state == nullptr)
+    return;
+
+  // Use the real width Yoga gave us
+  const CGFloat w = self.bounds.size.width > 1 ? self.bounds.size.width : 320;
+
+  CGSize size = [_view sizeForLayoutWithConstrainedTo:CGSizeMake(w, 0)];
+
+  PCSegmentedControlStateFrameSize next;
+  next.frameSize = {(Float)size.width, (Float)size.height};
+  _state->updateState(std::move(next));
+}
+
+@end

package/ios/PCSegmentedControl.swift

@@ -0,0 +1,200 @@
+import UIKit
+
+// MARK: - Segment model (bridged from ObjC++ as dictionaries)
+
+struct PCSegmentedControlSegment {
+    let label: String
+    let value: String
+    let disabled: Bool
+    let icon: String
+}
+
+@objcMembers
+public final class PCSegmentedControlView: UIControl {
+    // MARK: - Props (set from ObjC++)
+
+    /// ObjC++ sets this as an array of dictionaries: [{label, value, disabled, icon}]
+    public var segments: [Any] = [] { didSet { rebuildControl() } }
+
+    /// Controlled selection by value. "" = no selection.
+    public var selectedValue: String = "" { didSet { updateSelection() } }
+
+    /// "enabled" | "disabled"
+    public var interactivity: String = "enabled" { didSet { updateEnabled() } }
+
+    /// iOS-specific: momentary mode (segment springs back after touch)
+    public var momentary: Bool = false { didSet { control.isMomentary = momentary } }
+
+    /// iOS-specific: segment widths proportional to content
+    public var apportionsSegmentWidthsByContent: Bool = false {
+        didSet { control.apportionsSegmentWidthsByContent = apportionsSegmentWidthsByContent }
+    }
+
+    /// iOS-specific: selected segment tint color (hex string)
+    public var selectedSegmentTintColor: String? { didSet { updateTintColor() } }
+
+    // MARK: - Events back to ObjC++
+
+    public var onSelect: ((Int, String) -> Void)?  // (index, value)
+
+    // MARK: - Internal
+
+    private let control = UISegmentedControl()
+    private var parsedSegments: [PCSegmentedControlSegment] = []
+
+    // MARK: - Init
+
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+        setup()
+    }
+
+    public required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setup()
+    }
+
+    private func setup() {
+        control.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(control)
+
+        NSLayoutConstraint.activate([
+            control.topAnchor.constraint(equalTo: topAnchor),
+            control.bottomAnchor.constraint(equalTo: bottomAnchor),
+            control.leadingAnchor.constraint(equalTo: leadingAnchor),
+            control.trailingAnchor.constraint(equalTo: trailingAnchor),
+        ])
+
+        control.addTarget(self, action: #selector(valueChanged), for: .valueChanged)
+    }
+
+    @objc private func valueChanged() {
+        let index = control.selectedSegmentIndex
+        guard index != UISegmentedControl.noSegment,
+              index >= 0, index < parsedSegments.count else { return }
+
+        let segment = parsedSegments[index]
+        onSelect?(index, segment.value)
+    }
+
+    // MARK: - Props handling
+
+    private func rebuildControl() {
+        parsedSegments = segments.compactMap { any in
+            guard let dict = any as? [String: Any] else { return nil }
+            let label = (dict["label"] as? String) ?? ""
+            let value = (dict["value"] as? String) ?? ""
+            let disabled = (dict["disabled"] as? String) == "disabled"
+            let icon = (dict["icon"] as? String) ?? ""
+            return PCSegmentedControlSegment(
+                label: label,
+                value: value,
+                disabled: disabled,
+                icon: icon
+            )
+        }
+
+        control.removeAllSegments()
+
+        for (index, segment) in parsedSegments.enumerated() {
+            // Try to use SF Symbol icon if available
+            if !segment.icon.isEmpty,
+               let sfImage = UIImage(systemName: segment.icon) {
+                control.insertSegment(with: sfImage, at: index, animated: false)
+            } else {
+                control.insertSegment(withTitle: segment.label, at: index, animated: false)
+            }
+
+            // Set enabled state for this segment
+            control.setEnabled(!segment.disabled, forSegmentAt: index)
+        }
+
+        updateSelection()
+        invalidateIntrinsicContentSize()
+    }
+
+    private func updateSelection() {
+        if selectedValue.isEmpty {
+            control.selectedSegmentIndex = UISegmentedControl.noSegment
+        } else if let index = parsedSegments.firstIndex(where: { $0.value == selectedValue }) {
+            control.selectedSegmentIndex = index
+        } else {
+            control.selectedSegmentIndex = UISegmentedControl.noSegment
+        }
+    }
+
+    private func updateEnabled() {
+        let enabled = interactivity != "disabled"
+        control.isEnabled = enabled
+        alpha = enabled ? 1.0 : 0.5
+    }
+
+    private func updateTintColor() {
+        if let colorString = selectedSegmentTintColor, !colorString.isEmpty {
+            control.selectedSegmentTintColor = UIColor(hex: colorString)
+        } else {
+            control.selectedSegmentTintColor = nil
+        }
+    }
+
+    // MARK: - Sizing
+
+    public override func sizeThatFits(_ size: CGSize) -> CGSize {
+        let fitted = control.sizeThatFits(CGSize(width: size.width, height: .greatestFiniteMagnitude))
+        return CGSize(
+            width: size.width > 0 ? size.width : fitted.width,
+            height: max(PCConstants.minTouchTargetHeight, fitted.height)
+        )
+    }
+
+    public override var intrinsicContentSize: CGSize {
+        let fitted = control.intrinsicContentSize
+        return CGSize(
+            width: fitted.width,
+            height: max(PCConstants.minTouchTargetHeight, fitted.height)
+        )
+    }
+
+    /// Called by the measuring pipeline to get the size for Yoga layout.
+    @objc public func sizeForLayout(withConstrainedTo constrainedSize: CGSize) -> CGSize {
+        let fitted = control.sizeThatFits(
+            CGSize(width: constrainedSize.width > 0 ? constrainedSize.width : .greatestFiniteMagnitude,
+                   height: .greatestFiniteMagnitude)
+        )
+        return CGSize(
+            width: constrainedSize.width > 0 ? constrainedSize.width : fitted.width,
+            height: max(PCConstants.minTouchTargetHeight, fitted.height)
+        )
+    }
+}
+
+// MARK: - UIColor hex extension
+
+private extension UIColor {
+    convenience init?(hex: String) {
+        var hexSanitized = hex.trimmingCharacters(in: .whitespacesAndNewlines)
+        hexSanitized = hexSanitized.replacingOccurrences(of: "#", with: "")
+
+        var rgb: UInt64 = 0
+        guard Scanner(string: hexSanitized).scanHexInt64(&rgb) else { return nil }
+
+        let length = hexSanitized.count
+        if length == 6 {
+            self.init(
+                red: CGFloat((rgb & 0xFF0000) >> 16) / 255.0,
+                green: CGFloat((rgb & 0x00FF00) >> 8) / 255.0,
+                blue: CGFloat(rgb & 0x0000FF) / 255.0,
+                alpha: 1.0
+            )
+        } else if length == 8 {
+            self.init(
+                red: CGFloat((rgb & 0xFF000000) >> 24) / 255.0,
+                green: CGFloat((rgb & 0x00FF0000) >> 16) / 255.0,
+                blue: CGFloat((rgb & 0x0000FF00) >> 8) / 255.0,
+                alpha: CGFloat(rgb & 0x000000FF) / 255.0
+            )
+        } else {
+            return nil
+        }
+    }
+}