react-native-platform-components 0.1.1 → 0.3.1

package/android/src/main/java/com/platformcomponents/PCSelectionMenuView.kt

@@ -1,9 +1,8 @@
 package com.platformcomponents
 
-import android.app.Activity
 import android.content.Context
-import android.content.ContextWrapper
 import android.text.InputType
+import android.util.Log
 import android.view.View
 import android.view.ViewGroup
 import android.widget.AdapterView
@@ -11,10 +10,7 @@ import android.widget.ArrayAdapter
 import android.widget.FrameLayout
 import android.widget.LinearLayout
 import android.widget.Spinner
-import android.content.DialogInterface
-import androidx.fragment.app.FragmentActivity
-import com.facebook.react.uimanager.ThemedReactContext
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import androidx.appcompat.widget.PopupMenu
 import com.google.android.material.textfield.MaterialAutoCompleteTextView
 import com.google.android.material.textfield.TextInputLayout
 
@@ -22,6 +18,10 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
 
   data class Option(val label: String, val data: String)
 
+  companion object {
+    private const val TAG = "PCSelectionMenu"
+  }
+
   // --- Props ---
   var options: List<Option> = emptyList()
   var selectedData: String = "" // sentinel for none
@@ -32,9 +32,6 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
   var anchorMode: String = "headless" // "inline" | "headless"
   var visible: String = "closed"      // "open" | "closed" (headless only)
 
-  // Kept for backward compatibility with your interface; headless uses Spinner regardless.
-  var presentation: String = "auto"   // "auto" | "popover" | "sheet"
-
   // Only used to choose inline rendering style.
   var androidMaterial: String? = "system" // "system" | "m3"
 
@@ -46,12 +43,14 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
   private var inlineLayout: TextInputLayout? = null
   private var inlineText: MaterialAutoCompleteTextView? = null
   private var inlineSpinner: Spinner? = null
+  private var inlineDropdownOverlay: View? = null
+  private var inlineSpinnerSuppressCount = 0
 
   // --- Headless UI (true picker) ---
-  private var headlessSpinner: Spinner? = null
-  private var headlessDismissHooked: Boolean = false
-
-  private var suppressSpinnerSelection = false
+  private var headlessMenu: PopupMenu? = null
+  private var headlessMenuShowing = false
+  private var headlessDismissProgrammatic = false
+  private var headlessDismissAfterSelect = false
 
   init {
     minimumHeight = 0
@@ -83,23 +82,35 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
   // ---- Public apply* (called by manager) ----
 
   fun applyOptions(newOptions: List<Option>) {
+    if (options == newOptions) return
     options = newOptions
+    Log.d(TAG, "applyOptions size=${options.size}")
     refreshAdapters()
     refreshSelections()
   }
 
   fun applySelectedData(data: String?) {
-    selectedData = data ?: ""
+    val next = data ?: ""
+    if (selectedData == next) return
+    selectedData = next
+    Log.d(TAG, "applySelectedData selectedData=$selectedData")
     refreshSelections()
   }
 
   fun applyInteractivity(value: String?) {
     interactivity = if (value == "disabled") "disabled" else "enabled"
+    Log.d(TAG, "applyInteractivity interactivity=$interactivity")
     updateEnabledState()
 
     // If disabled while open, request close.
     if (interactivity != "enabled" && visible == "open") {
-      onRequestClose?.invoke()
+      Log.d(TAG, "applyInteractivity disabled while open -> requestClose")
+      if (anchorMode == "headless" && headlessMenuShowing) {
+        headlessDismissProgrammatic = true
+        headlessMenu?.dismiss()
+      } else {
+        onRequestClose?.invoke()
+      }
     }
   }
 
@@ -107,6 +118,7 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
     if (placeholder == value) return
     placeholder = value
     inlineLayout?.hint = placeholder
+    // Spinner doesn't support placeholder
   }
 
   fun applyAnchorMode(value: String?) {
@@ -116,6 +128,7 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
     }
     if (anchorMode == newMode) return
     anchorMode = newMode
+    Log.d(TAG, "applyAnchorMode anchorMode=$anchorMode")
     rebuildUI()
   }
 
@@ -124,21 +137,18 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
       "open", "closed" -> value
       else -> "closed"
     }
+    Log.d(TAG, "applyVisible visible=$visible anchorMode=$anchorMode")
 
     if (anchorMode != "headless") return
 
     if (visible == "open") {
       presentHeadlessIfNeeded()
     } else {
-      // We can't reliably force-close a Spinner dropdown, but we can at least signal state.
-      // Most apps will set visible=closed after onSelect/onRequestClose anyway.
-    }
-  }
-
-  fun applyPresentation(value: String?) {
-    presentation = when (value) {
-      "auto", "popover", "sheet" -> value
-      else -> "auto"
+      Log.d(TAG, "applyVisible close -> dismiss")
+      if (headlessMenuShowing) {
+        headlessDismissProgrammatic = true
+        headlessMenu?.dismiss()
+      }
     }
   }
 
@@ -152,15 +162,22 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
   // ---- UI building ----
 
   private fun rebuildUI() {
+    inlineText?.dismissDropDown()
+    detachInlineDropdownOverlay()
+    inlineDropdownOverlay = null
     removeAllViews()
     inlineLayout = null
     inlineText = null
     inlineSpinner = null
-    headlessSpinner = null
-    headlessDismissHooked = false
+    inlineSpinnerSuppressCount = 0
+    headlessMenu = null
+    headlessMenuShowing = false
+    headlessDismissProgrammatic = false
+    headlessDismissAfterSelect = false
 
     // Headless should be invisible but anchorable.
-    alpha = if (anchorMode == "headless") 0f else 1f
+    alpha = if (anchorMode == "headless") 0.01f else 1f
+    Log.d(TAG, "rebuildUI anchorMode=$anchorMode alpha=$alpha")
 
     if (anchorMode == "inline") {
       buildInline()
@@ -178,63 +195,129 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
     val mode = parseMaterial(androidMaterial)
 
     if (mode == MaterialMode.M3) {
-      // M3 inline = exposed dropdown look, but forced read-only
+      // M3 exposed dropdown menu - the standard Material 3 way
       val til = TextInputLayout(context).apply {
         layoutParams = FrameLayout.LayoutParams(
           FrameLayout.LayoutParams.MATCH_PARENT,
-          FrameLayout.LayoutParams.MATCH_PARENT
+          FrameLayout.LayoutParams.WRAP_CONTENT
         )
         hint = placeholder
+        endIconMode = TextInputLayout.END_ICON_DROPDOWN_MENU
       }
 
-      val actv = MaterialAutoCompleteTextView(til.context).apply {
+      val actv = InlineAutoCompleteTextView(til.context)
+      inlineText = actv
+      actv.apply {
         layoutParams = LinearLayout.LayoutParams(
           ViewGroup.LayoutParams.MATCH_PARENT,
           ViewGroup.LayoutParams.WRAP_CONTENT
         )
-        isSingleLine = true
-        threshold = 0
 
-        // behave like picker
-        inputType = InputType.TYPE_NULL
+        // Keep it a real text editor so the popup behaves modally
+        inputType = InputType.TYPE_CLASS_TEXT
+
+        // Prevent keyboard
+        showSoftInputOnFocus = false
+
+        // Optional: keep it from being typed into
         keyListener = null
         isCursorVisible = false
-        isFocusable = false
-        isFocusableInTouchMode = false
 
-        setOnClickListener {
-          if (interactivity == "enabled") showDropDown()
-        }
+        // Nice UX: click anywhere opens dropdown
+        setOnClickListener { showDropDown() }
 
         setOnItemClickListener { _, _, position, _ ->
           val opt = options.getOrNull(position) ?: return@setOnItemClickListener
           selectedData = opt.data
           onSelect?.invoke(position, opt.label, opt.data)
+          detachInlineDropdownOverlay()
+        }
+
+        setOnTouchListener { _, e ->
+          if (e.action == android.view.MotionEvent.ACTION_UP) {
+            showDropDown()
+          }
+          false // let default handling run
         }
       }
 
       til.addView(actv)
       addView(til)
       inlineLayout = til
-      inlineText = actv
     } else {
-      // SYSTEM inline = native spinner
-      val sp = Spinner(context, Spinner.MODE_DROPDOWN).apply {
-        layoutParams = FrameLayout.LayoutParams(
-          FrameLayout.LayoutParams.MATCH_PARENT,
-          FrameLayout.LayoutParams.WRAP_CONTENT
-        )
+      // SYSTEM mode: Use custom Spinner with dropdown mode to ensure callbacks fire
+      val sp = object : Spinner(context, null, android.R.attr.spinnerStyle, Spinner.MODE_DROPDOWN) {
+        override fun setSelection(position: Int, animate: Boolean) {
+          val oldPos = selectedItemPosition
+          super.setSelection(position, animate)
+
+          // Manually trigger onItemSelectedListener if selection changed
+          // This is needed because Spinner doesn't always trigger the callback when
+          // the selection changes via user interaction with the dropdown
+          if (position != oldPos && onItemSelectedListener != null) {
+            post {
+              onItemSelectedListener?.onItemSelected(
+                this,
+                selectedView,
+                position,
+                getItemIdAtPosition(position)
+              )
+            }
+          }
+        }
+
+        override fun setSelection(position: Int) {
+          val oldPos = selectedItemPosition
+          super.setSelection(position)
+
+          // Manually trigger onItemSelectedListener if selection changed
+          if (position != oldPos && onItemSelectedListener != null) {
+            post {
+              onItemSelectedListener?.onItemSelected(
+                this,
+                selectedView,
+                position,
+                getItemIdAtPosition(position)
+              )
+            }
+          }
+        }
       }
 
+      // Set listener FIRST, before adapter
       sp.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
-        override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
-          if (suppressSpinnerSelection) return
+        override fun onItemSelected(
+          parent: AdapterView<*>,
+          view: View?,
+          position: Int,
+          id: Long
+        ) {
+          // If suppress count > 0, this is a programmatic change (ignore it)
+          if (inlineSpinnerSuppressCount > 0) return
+
+          if (interactivity != "enabled") return
+
           val opt = options.getOrNull(position) ?: return
+
+          // Only fire callback if selection actually changed
           if (opt.data == selectedData) return
-          selectedData = opt.data
+
+          // Don't update selectedData here - let applySelectedData handle it
+          // This ensures refreshSelections() is called to update the Spinner's display
           onSelect?.invoke(position, opt.label, opt.data)
         }
-        override fun onNothingSelected(parent: AdapterView<*>?) = Unit
+
+        override fun onNothingSelected(parent: AdapterView<*>) {
+          // No-op
+        }
+      }
+
+      sp.apply {
+        layoutParams = FrameLayout.LayoutParams(
+          FrameLayout.LayoutParams.MATCH_PARENT,
+          FrameLayout.LayoutParams.WRAP_CONTENT
+        )
+        visibility = View.VISIBLE
       }
 
       addView(sp)
@@ -243,32 +326,35 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
   }
 
   private fun buildHeadless() {
-    // Headless = TRUE picker using Spinner dropdown
-    val sp = Spinner(context, Spinner.MODE_DROPDOWN).apply {
-      layoutParams = FrameLayout.LayoutParams(1, 1)
-      // keep it anchorable but not interactive unless we programmatically open it
-      isClickable = true
-      isFocusable = false
-      isFocusableInTouchMode = false
-    }
-
-    sp.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
-      override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
-        if (suppressSpinnerSelection) return
-        val opt = options.getOrNull(position) ?: return
-
-        selectedData = opt.data
-        onSelect?.invoke(position, opt.label, opt.data)
-
-        // After selection, close contract.
-        onRequestClose?.invoke()
+    val popup = PopupMenu(context, this@PCSelectionMenuView).apply {
+      setOnMenuItemClickListener { item ->
+        val index = item.itemId
+        val opt = options.getOrNull(index)
+        Log.d(
+          TAG,
+          "headless onMenuItemClick index=$index optData=${opt?.data} selectedData=$selectedData"
+        )
+        headlessDismissAfterSelect = true
+        handleHeadlessSelection(index)
+        true
+      }
+      setOnDismissListener {
+        val programmatic = headlessDismissProgrammatic || headlessDismissAfterSelect
+        headlessDismissProgrammatic = false
+        headlessDismissAfterSelect = false
+        headlessMenuShowing = false
+        if (programmatic) {
+          Log.d(TAG, "headless onDismiss programmatic")
+        } else {
+          Log.d(TAG, "headless onDismiss -> requestClose")
+          onRequestClose?.invoke()
+        }
       }
-
-      override fun onNothingSelected(parent: AdapterView<*>?) = Unit
     }
 
-    addView(sp)
-    headlessSpinner = sp
+    headlessMenu = popup
+    Log.d(TAG, "buildHeadless menu=${System.identityHashCode(popup)}")
+    refreshHeadlessMenu()
   }
 
   private fun updateEnabledState() {
@@ -276,108 +362,166 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
     inlineLayout?.isEnabled = enabled
     inlineText?.isEnabled = enabled
     inlineSpinner?.isEnabled = enabled
-    headlessSpinner?.isEnabled = enabled
   }
 
   private fun refreshAdapters() {
     val labels = options.map { it.label }
 
     inlineText?.let { actv ->
-      actv.setAdapter(ArrayAdapter(actv.context, android.R.layout.simple_list_item_1, labels))
+      val adapter = ArrayAdapter(actv.context, android.R.layout.simple_list_item_1, labels)
+      actv.setAdapter(adapter)
     }
 
-    fun applySpinnerAdapter(sp: Spinner) {
+    inlineSpinner?.let { sp ->
+      suppressInlineSpinnerCallbacks(sp)
       val adapter = ArrayAdapter(sp.context, android.R.layout.simple_spinner_item, labels)
       adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
       sp.adapter = adapter
     }
 
-    inlineSpinner?.let { applySpinnerAdapter(it) }
-    headlessSpinner?.let { applySpinnerAdapter(it) }
+    refreshHeadlessMenu()
   }
 
   private fun refreshSelections() {
     val idx = options.indexOfFirst { it.data == selectedData }
-    val label = if (idx >= 0) options[idx].label else ""
 
-    inlineText?.setText(label, false)
+    inlineText?.let { actv ->
+      if (idx >= 0) {
+        // Show selected value
+        actv.setText(options[idx].label, false)
+      } else {
+        // Clear text to show placeholder
+        actv.setText("", false)
+      }
+    }
 
-    fun setSpinnerSelection(sp: Spinner) {
+    inlineSpinner?.let { sp ->
       if (options.isEmpty()) return
       val target = if (idx >= 0) idx else 0
-      if (sp.selectedItemPosition == target) return
+      // Always call setSelection to ensure the view is refreshed
+      // Even if the position hasn't changed, we need to update the displayed text
+      suppressInlineSpinnerCallbacks(sp)
+      sp.setSelection(target, false)
+    }
+  }
 
-      suppressSpinnerSelection = true
-      try {
-        sp.setSelection(target, false)
-      } finally {
-        suppressSpinnerSelection = false
+  // ---- Inline dropdown overlay ----
+
+  private inner class InlineAutoCompleteTextView(context: Context) :
+    MaterialAutoCompleteTextView(context) {
+    override fun showDropDown() {
+      if (interactivity != "enabled" || !isEnabled) return
+      attachInlineDropdownOverlay()
+      super.showDropDown()
+      post {
+        if (!isPopupShowing) {
+          detachInlineDropdownOverlay()
+        }
       }
     }
 
-    inlineSpinner?.let { setSpinnerSelection(it) }
-    headlessSpinner?.let { setSpinnerSelection(it) }
+    override fun dismissDropDown() {
+      super.dismissDropDown()
+      detachInlineDropdownOverlay()
+    }
+  }
+
+  private fun attachInlineDropdownOverlay() {
+    if (inlineDropdownOverlay?.parent != null) return
+    val parent = findInlineOverlayParent() ?: return
+    // Fullscreen touch guard to dismiss without leaking taps to underlying views.
+    val overlay = inlineDropdownOverlay
+      ?: View(parent.context).apply {
+        layoutParams = ViewGroup.LayoutParams(
+          ViewGroup.LayoutParams.MATCH_PARENT,
+          ViewGroup.LayoutParams.MATCH_PARENT
+        )
+        isClickable = true
+        importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
+        setOnTouchListener { _, event ->
+          if (event.action == android.view.MotionEvent.ACTION_DOWN) {
+            inlineText?.dismissDropDown()
+            detachInlineDropdownOverlay()
+          }
+          true
+        }
+      }.also { inlineDropdownOverlay = it }
+    parent.addView(overlay)
+  }
+
+  private fun detachInlineDropdownOverlay() {
+    val overlay = inlineDropdownOverlay ?: return
+    (overlay.parent as? ViewGroup)?.removeView(overlay)
+  }
+
+  private fun findInlineOverlayParent(): ViewGroup? {
+    val activity = context.findActivity()
+    val contentRoot = activity?.findViewById<ViewGroup>(android.R.id.content)
+    if (contentRoot != null) return contentRoot
+    val activityRoot = activity?.window?.decorView as? ViewGroup
+    if (activityRoot != null) return activityRoot
+    return rootView as? ViewGroup
   }
 
   // ---- Headless open ----
 
   private fun presentHeadlessIfNeeded() {
-    val sp = headlessSpinner ?: return
+    val popup = headlessMenu ?: return
     if (interactivity != "enabled") {
+      Log.d(TAG, "presentHeadlessIfNeeded interactivity=$interactivity -> requestClose")
       onRequestClose?.invoke()
       return
     }
     post {
       if (!isAttachedToWindow) {
+        Log.d(TAG, "presentHeadlessIfNeeded not attached -> requestClose")
         onRequestClose?.invoke()
         return@post
       }
-
-      // Make dropdown match the anchor view width
-      val anchorW = this@PCSelectionMenuView.width
-      if (anchorW > 0) {
-        sp.dropDownWidth = anchorW
+      Log.d(
+        TAG,
+        "presentHeadlessIfNeeded attached width=${this@PCSelectionMenuView.width} alpha=$alpha"
+      )
+
+      refreshHeadlessMenu()
+      if (!headlessMenuShowing) {
+        Log.d(TAG, "presentHeadlessIfNeeded show items=${options.size}")
+        headlessDismissProgrammatic = false
+        headlessDismissAfterSelect = false
+        headlessMenuShowing = true
+        popup.show()
       }
+    }
+  }
 
-      // Align dropdown’s left edge with the anchor’s left edge.
-      // (X positioning comes from the anchor itself; this is just extra explicit.)
-      sp.dropDownHorizontalOffset = 0
-      sp.dropDownVerticalOffset = 0
+  private fun handleHeadlessSelection(position: Int) {
+    val opt = options.getOrNull(position) ?: return
+    Log.d(TAG, "handleHeadlessSelection pos=$position data=${opt.data}")
+    selectedData = opt.data
+    onSelect?.invoke(position, opt.label, opt.data)
+  }
 
-      hookSpinnerDismiss(sp)
-      sp.performClick()
+  private fun refreshHeadlessMenu() {
+    val menu = headlessMenu?.menu ?: return
+    menu.clear()
+    options.forEachIndexed { index, opt ->
+      menu.add(0, index, index, opt.label)
     }
   }
 
-  /**
-   * Spinner doesn't expose dismiss callbacks publicly. Many Android builds use an internal
-   * DropdownPopup (ListPopupWindow) stored in a private field. We hook it if possible.
-   *
-   * If this fails, selection still works, but you may not get an "onRequestClose" when dismissed.
-   */
-  private fun hookSpinnerDismiss(sp: Spinner) {
-    if (headlessDismissHooked) return
-
-    try {
-      val f = Spinner::class.java.getDeclaredField("mPopup")
-      f.isAccessible = true
-      val popupObj = f.get(sp)
-
-      // AOSP DropdownPopup extends ListPopupWindow on many versions.
-      val setOnDismiss = popupObj?.javaClass?.methods?.firstOrNull { m ->
-        m.name == "setOnDismissListener" && m.parameterTypes.size == 1
-      }
-
-      if (setOnDismiss != null) {
-        val listener = DialogInterface.OnDismissListener {
-          onRequestClose?.invoke()
-        }
-        setOnDismiss.invoke(popupObj, listener)
-        headlessDismissHooked = true
-      }
-    } catch (_: Throwable) {
-      // ignore; no dismiss hook available
+  private fun suppressInlineSpinnerCallbacks(sp: Spinner) {
+    inlineSpinnerSuppressCount += 1
+    val posted = sp.post {
+      inlineSpinnerSuppressCount = (inlineSpinnerSuppressCount - 1).coerceAtLeast(0)
     }
+    if (!posted) {
+      inlineSpinnerSuppressCount = (inlineSpinnerSuppressCount - 1).coerceAtLeast(0)
+    }
+  }
+
+  override fun onDetachedFromWindow() {
+    detachInlineDropdownOverlay()
+    super.onDetachedFromWindow()
   }
 
   // ---- Helpers ----
@@ -390,21 +534,4 @@ class PCSelectionMenuView(context: Context) : FrameLayout(context) {
       "system", null -> MaterialMode.SYSTEM
       else -> MaterialMode.SYSTEM
     }
-
-  private fun findFragmentActivity(): FragmentActivity? {
-    val trc = context as? ThemedReactContext
-    val a1 = trc?.currentActivity
-    if (a1 is FragmentActivity) return a1
-
-    var c: Context? = context
-    while (c is ContextWrapper) {
-      if (c is FragmentActivity) return c
-      val base = (c as ContextWrapper).baseContext
-      if (base == c) break
-      c = base
-    }
-
-    val a2 = (context as? Activity)
-    return a2 as? FragmentActivity
-  }
 }

package/android/src/main/java/com/platformcomponents/PCSelectionMenuViewManager.kt

@@ -1,5 +1,6 @@
 package com.platformcomponents
 
+import android.util.Log
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.SimpleViewManager
@@ -15,6 +16,10 @@ class PCSelectionMenuViewManager :
   SimpleViewManager<PCSelectionMenuView>(),
   PCSelectionMenuManagerInterface<PCSelectionMenuView> {
 
+  companion object {
+    private const val TAG = "PCSelectionMenu"
+  }
+
   private val delegate: ViewManagerDelegate<PCSelectionMenuView> =
     PCSelectionMenuManagerDelegate(this)
 
@@ -73,10 +78,6 @@ class PCSelectionMenuViewManager :
     view.applyVisible(value)
   }
 
-  override fun setPresentation(view: PCSelectionMenuView, value: String?) {
-    view.applyPresentation(value)
-  }
-
   override fun setAndroid(view: PCSelectionMenuView, value: ReadableMap?) {
     val material =
       if (value != null && value.hasKey("material") && !value.isNull("material")) value.getString("material") else null

package/ios/PCDatePickerView.swift

@@ -159,9 +159,7 @@ public final class PCDatePickerView: UIControl,
         picker.layoutIfNeeded()
 
         let fitted = picker.systemLayoutSizeFitting(UIView.layoutFittingCompressedSize)
-        let minH: CGFloat = (preferredStyle == "wheels") ? 216 : 160
-        let minW: CGFloat = 280
-        return CGSize(width: max(minW, fitted.width), height: max(minH, fitted.height))
+        return fitted
     }
 
     // MARK: - Presentation
@@ -221,15 +219,8 @@ public final class PCDatePickerView: UIControl,
         picker.translatesAutoresizingMaskIntoConstraints = false
         vc.view.addSubview(picker)
 
-        NSLayoutConstraint.activate([
-            picker.topAnchor.constraint(equalTo: vc.view.topAnchor),
-            picker.bottomAnchor.constraint(equalTo: vc.view.bottomAnchor),
-            picker.leadingAnchor.constraint(equalTo: vc.view.leadingAnchor),
-            picker.trailingAnchor.constraint(equalTo: vc.view.trailingAnchor),
-        ])
-
         let size = popoverContentSize()
-        vc.preferredContentSize = size
+        vc.preferredContentSize = size 
 
         // ✅ Anchored popover-style (not a full sheet)
         vc.modalPresentationStyle = .popover