Add dynamic anchor frame and boundary avoidance

  - Change anchorFrame from static CGRect to closure for dynamic positioning
    - Popup position now updates when source view moves (e.g., window resize)
    - Use AnchorFrameProvider wrapper for @unchecked Sendable compatibility

  - Add boundary avoidance to keep popups within screen bounds
    - New edgePadding config (default 16pt)
    - New constrainedEdges config (.horizontal by default, .vertical optional)
    - Automatically adjust position when popup would overflow edges

  - Simplify PopupAnchoredStackView architecture
    - Replace stored popupFrames with computed frame(for:) method
    - Fix "Publishing changes from within view updates" warnings
    - Use @mainactor for proper concurrency isolation

  API change: present(anchoredTo:) now takes a closure instead of CGRect
    Before: .present(anchoredTo: buttonFrame)
    After:  .present(anchoredTo: { buttonFrame })

Author: vidy

Sources/Internal/Configurables/Local/LocalConfig+Anchored.swift

@@ -22,6 +22,8 @@ public class LocalConfigAnchored: LocalConfig { required public init() {}
     public var popupAnchor: PopupAnchorPoint = .top
     public var offset: CGPoint = .zero
     public var isTapOutsidePassThroughEnabled: Bool = false
+    public var edgePadding: CGFloat = 16
+    public var constrainedEdges: Edge.Set = .horizontal
 
     // MARK: Inactive Variables (inherited from LocalConfig protocol)
     public var ignoredSafeAreaEdges: Edge.Set = []
@@ -48,6 +50,16 @@ public extension LocalConfigAnchored {
     /// Enables touch pass-through when tapping outside the popup
     /// When enabled, touches outside the popup are passed to underlying views instead of being blocked
     func tapOutsidePassThrough(_ enabled: Bool) -> Self { self.isTapOutsidePassThroughEnabled = enabled; return self }
+
+    /// Configures edge padding and which edges to constrain
+    /// - Parameters:
+    ///   - value: Padding value from screen edges
+    ///   - edges: Which edges to constrain (.horizontal, .vertical, .all, or [] to disable)
+    func edgePadding(_ value: CGFloat, edges: Edge.Set = .horizontal) -> Self {
+        self.edgePadding = value
+        self.constrainedEdges = edges
+        return self
+    }
 }
 
 // MARK: - Public Type Alias

Sources/Internal/Models/AnyPopup.swift

@@ -61,7 +61,7 @@ extension AnyPopup {
     func updatedEnvironmentObject(_ environmentObject: some ObservableObject) -> AnyPopup { updated { $0._body = .init(_body.environmentObject(environmentObject)) }}
     func updatedKeyboardDismissal(_ shouldDismiss: Bool) -> AnyPopup { updated { $0.shouldDismissKeyboardOnPopupToggle = shouldDismiss }}
     func startDismissTimerIfNeeded(_ popupStack: PopupStack) -> AnyPopup { updated { $0._dismissTimer?.schedule { popupStack.modify(.removePopup(self)) }}}
-    func updatedAnchorFrame(_ frame: CGRect) -> AnyPopup { updated { $0.config.anchorFrame = frame }}
+    func updatedAnchorFrameProvider(_ provider: @escaping () -> CGRect) -> AnyPopup { updated { $0.config.anchorFrameProvider = .init(closure: provider) }}
 }
 private extension AnyPopup {
     func updated(_ customBuilder: (inout AnyPopup) -> ()) -> AnyPopup {

Sources/Internal/Models/AnyPopupConfig.swift

@@ -11,6 +11,18 @@
 
 import SwiftUI
 
+/// Wrapper to bypass Sendable compiler checks for anchor frame closure.
+///
+/// This is safe because:
+/// 1. The closure only captures @State variables which are main-thread isolated in SwiftUI
+/// 2. The closure is only called from UI layer (main thread) in calculatePopupPosition()
+/// 3. No actual cross-thread access occurs - the Sendable requirement is only for
+///    passing AnyPopup through async boundaries, not for concurrent execution
+struct AnchorFrameProvider: @unchecked Sendable {
+    let closure: () -> CGRect
+    func callAsFunction() -> CGRect { closure() }
+}
+
 struct AnyPopupConfig: LocalConfig, Sendable { init() {}
     // MARK: Content
     var alignment: PopupAlignment = .center
@@ -28,11 +40,14 @@ struct AnyPopupConfig: LocalConfig, Sendable { init() {}
     var dragGestureAreaSize: CGFloat = 0
 
     // MARK: Anchored-specific
-    var anchorFrame: CGRect = .zero
+    var anchorFrameProvider: AnchorFrameProvider? = nil
+    var anchorFrame: CGRect { anchorFrameProvider?() ?? .zero }
     var originAnchor: PopupAnchorPoint = .bottom
     var popupAnchor: PopupAnchorPoint = .top
     var anchorOffset: CGPoint = .zero
     var isTapOutsidePassThroughEnabled: Bool = false
+    var edgePadding: CGFloat = 16
+    var constrainedEdges: Edge.Set = .horizontal
 }
 
 // MARK: Initialize
@@ -56,6 +71,8 @@ extension AnyPopupConfig {
             self.popupAnchor = anchoredConfig.popupAnchor
             self.anchorOffset = anchoredConfig.offset
             self.isTapOutsidePassThroughEnabled = anchoredConfig.isTapOutsidePassThroughEnabled
+            self.edgePadding = anchoredConfig.edgePadding
+            self.constrainedEdges = anchoredConfig.constrainedEdges
         }
     }
 }

Sources/Internal/UI/PopupAnchoredStackView.swift

@@ -17,11 +17,23 @@ class AnchoredPopupsContainer: UIView {
 
     private var hostingController: UIHostingController<AnyView>?
     private var popupModel = AnchoredPopupModel()
+    private var lastBoundsSize: CGSize = .zero
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        guard bounds.size != lastBoundsSize else { return }
+        lastBoundsSize = bounds.size
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.popupModel.containerSize = self.bounds.size
+        }
+    }
 
     /// Returns true only if touch is inside a popup frame
     override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
-        for (_, frame) in popupModel.popupFrames {
-            if frame.contains(point) {
+        for popup in popupModel.popups {
+            if let frame = popupModel.frame(for: popup), frame.contains(point) {
                 return true
             }
         }
@@ -30,30 +42,17 @@ class AnchoredPopupsContainer: UIView {
 
     /// Returns hit view only if touch is inside a popup frame, otherwise passes through
     override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
-        for (_, frame) in popupModel.popupFrames {
-            if frame.contains(point) {
-                // Touch inside popup, let UIHostingController handle it
+        for popup in popupModel.popups {
+            if let frame = popupModel.frame(for: popup), frame.contains(point) {
                 return hostingController?.view.hitTest(point, with: event)
             }
         }
-        // Touch outside all popups, pass through
         return nil
     }
 
     /// Updates popups in the container
     func updatePopups(_ popups: [AnyPopup], viewModel: VM.AnchoredStack) {
-        // Clean up frames for removed popups
-        let currentIds = Set(popups.map { $0.id.rawValue })
-        let existingIds = Set(popupModel.popupFrames.keys)
-        for id in existingIds.subtracting(currentIds) {
-            popupModel.popupFrames.removeValue(forKey: id)
-            popupModel.popupSizes.removeValue(forKey: id)
-        }
-
-        popupModel.popups = popups
-        popupModel.viewModel = viewModel
-
-        // Create hosting controller if needed
+        // Create hosting controller if needed (sync, only once)
         if hostingController == nil {
             let containerView = AnchoredPopupContainerView(model: popupModel)
             let hc = UIHostingController(rootView: AnyView(containerView))
@@ -63,6 +62,20 @@ class AnchoredPopupsContainer: UIView {
             addSubview(hc.view)
             hostingController = hc
         }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+
+            // Clean up sizes for removed popups
+            let currentIds = Set(popups.map { $0.id.rawValue })
+            let existingIds = Set(self.popupModel.popupSizes.keys)
+            for id in existingIds.subtracting(currentIds) {
+                self.popupModel.popupSizes.removeValue(forKey: id)
+            }
+
+            self.popupModel.popups = popups
+            self.popupModel.viewModel = viewModel
+        }
     }
 
     /// Installs container directly on Window (above rootViewController.view)
@@ -87,11 +100,26 @@ class AnchoredPopupsContainer: UIView {
 
 // MARK: - Popup Model (ObservableObject for SwiftUI)
 
+@MainActor
 private class AnchoredPopupModel: ObservableObject {
     @Published var popups: [AnyPopup] = []
     @Published var popupSizes: [String: CGSize] = [:]
-    @Published var popupFrames: [String: CGRect] = [:]  // Store frame for hitTest
+    @Published var containerSize: CGSize = .zero
     var viewModel: VM.AnchoredStack?
+
+    /// Calculate frame for popup (called during render, not stored)
+    func frame(for popup: AnyPopup) -> CGRect? {
+        let popupId = popup.id.rawValue
+        guard let size = popupSizes[popupId],
+              let viewModel = viewModel else { return nil }
+
+        let position = viewModel.calculatePopupPosition(
+            for: popup,
+            popupSize: size,
+            containerSize: containerSize
+        )
+        return CGRect(origin: position, size: size)
+    }
 }
 
 // MARK: - SwiftUI Container View
@@ -103,41 +131,21 @@ private struct AnchoredPopupContainerView: View {
         ZStack(alignment: .topLeading) {
             ForEach(model.popups, id: \.self) { popup in
                 let popupId = popup.id.rawValue
-                let hasSize = model.popupSizes[popupId] != nil
+                let frame = model.frame(for: popup)
 
                 PopupContentView(popup: popup, viewModel: model.viewModel)
-                    .opacity(hasSize ? 1 : 0)
+                    .opacity(frame != nil ? 1 : 0)
                     .sizeReader { size in
                         if model.popupSizes[popupId] != size {
                             model.popupSizes[popupId] = size
                         }
                     }
-                    .offset(popupOffset(for: popup))
+                    .offset(x: frame?.origin.x ?? 0, y: frame?.origin.y ?? 0)
             }
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
         .edgesIgnoringSafeArea(.all)
     }
-
-    /// Calculate offset for popup positioning and store frame for hitTest
-    private func popupOffset(for popup: AnyPopup) -> CGSize {
-        let popupId = popup.id.rawValue
-        guard let size = model.popupSizes[popupId], let viewModel = model.viewModel else {
-            return .zero
-        }
-
-        let position = viewModel.calculatePopupPosition(for: popup, popupSize: size)
-
-        // Store frame for hitTest
-        let frame = CGRect(origin: position, size: size)
-        if model.popupFrames[popupId] != frame {
-            DispatchQueue.main.async {
-                self.model.popupFrames[popupId] = frame
-            }
-        }
-
-        return CGSize(width: position.x, height: position.y)
-    }
 }
 
 /// SwiftUI content for a single popup

Sources/Internal/UI/PopupView.swift

@@ -96,7 +96,8 @@ private extension PopupView {
         await updateViewModels { $0.setup(updatePopupAction: updatePopup, closePopupAction: closePopup) }
     }}
     func onScreenChange(_ screenReader: GeometryProxy) { Task {
-        await updateViewModels { await $0.updateScreen(screenHeight: screenReader.size.height + screenReader.safeAreaInsets.top + screenReader.safeAreaInsets.bottom, screenSafeArea: screenReader.safeAreaInsets) }
+        let screenHeight = screenReader.size.height + screenReader.safeAreaInsets.top + screenReader.safeAreaInsets.bottom
+        await updateViewModels { await $0.updateScreen(screenHeight: screenHeight, screenSafeArea: screenReader.safeAreaInsets) }
     }}
     func onPopupsHeightChange(_ p: Any) { Task {
         await updateViewModels { await $0.updatePopups(stack.popups) }

Sources/Internal/View Models/ViewModel+AnchoredStack.swift

@@ -92,7 +92,7 @@ extension VM.AnchoredStack {
 // MARK: Position Calculation
 extension VM.AnchoredStack {
     /// Calculates the position for the popup based on anchor frame and anchor points
-    func calculatePopupPosition(for popup: AnyPopup, popupSize: CGSize) -> CGPoint {
+    func calculatePopupPosition(for popup: AnyPopup, popupSize: CGSize, containerSize: CGSize = .zero) -> CGPoint {
         let config = popup.config
         let anchorFrame = config.anchorFrame
 
@@ -102,11 +102,66 @@ extension VM.AnchoredStack {
         // Calculate the offset needed based on popup anchor point
         let popupOffset = calculatePopupOffset(for: config.popupAnchor, popupSize: popupSize)
 
-        // Final position = origin point - popup offset + user offset
-        return CGPoint(
+        // Initial position
+        var popoverFrame = CGRect(
             x: originPoint.x - popupOffset.x + config.anchorOffset.x,
-            y: originPoint.y - popupOffset.y + config.anchorOffset.y
+            y: originPoint.y - popupOffset.y + config.anchorOffset.y,
+            width: popupSize.width,
+            height: popupSize.height
         )
+
+        // Apply boundary avoidance
+        popoverFrame = applyBoundaryAvoidance(frame: popoverFrame, config: config, screenSize: containerSize)
+
+        return popoverFrame.origin
+    }
+
+    /// Keeps popup within screen bounds based on configured edge constraints
+    private func applyBoundaryAvoidance(frame: CGRect, config: AnyPopupConfig, screenSize: CGSize) -> CGRect {
+        let edges = config.constrainedEdges
+
+        // No constraints, return original frame
+        guard !edges.isEmpty else { return frame }
+
+        // Skip if screen size not initialized
+        guard screenSize.width > 0, screenSize.height > 0 else { return frame }
+
+        var popoverFrame = frame
+        let padding = config.edgePadding
+
+        // Horizontal constraint
+        if edges.contains(.horizontal) {
+            let minX = screen.safeArea.leading + padding
+            let maxX = screenSize.width - screen.safeArea.trailing - padding
+
+            // Left edge overflow
+            if popoverFrame.origin.x < minX {
+                popoverFrame.origin.x = minX
+            }
+            // Right edge overflow
+            if popoverFrame.maxX > maxX {
+                let difference = popoverFrame.maxX - maxX
+                popoverFrame.origin.x -= difference
+            }
+        }
+
+        // Vertical constraint
+        if edges.contains(.vertical) {
+            let minY = screen.safeArea.top + padding
+            let maxY = screenSize.height - screen.safeArea.bottom - padding
+
+            // Top edge overflow
+            if popoverFrame.origin.y < minY {
+                popoverFrame.origin.y = minY
+            }
+            // Bottom edge overflow
+            if popoverFrame.maxY > maxY {
+                let difference = popoverFrame.maxY - maxY
+                popoverFrame.origin.y -= difference
+            }
+        }
+
+        return popoverFrame
     }
 
     /// Calculates a point on the anchor frame based on the anchor point type

Sources/Public/Present/Public+Present+Popup.swift

@@ -41,29 +41,32 @@ public extension AnchoredPopup {
      Presents the anchored popup positioned relative to a source view frame.
 
      - Parameters:
-        - anchorFrame: The frame of the source view to anchor the popup to (in global coordinates).
+        - anchorFrameProvider: A closure that returns the frame of the source view (in global coordinates).
+          The closure is called each time the popup position needs to be recalculated.
+        - customID: Optional custom identifier for the popup.
         - popupStackID: The identifier registered in one of the application windows in which the popup is to be displayed.
 
-     - Important: The **anchorFrame** should be in global screen coordinates. Use `.frameReader` or `GeometryReader` to obtain the frame.
+     - Important: The frame returned by **anchorFrameProvider** should be in global screen coordinates.
+       Use `.frameReader` or `GeometryReader` to obtain the frame.
 
      ## Usage
      ```swift
      @State private var buttonFrame: CGRect = .zero
 
      Button("Show") {
-         Task { await MyAnchoredPopup().present(anchoredTo: buttonFrame) }
+         Task { await MyAnchoredPopup().present(anchoredTo: { buttonFrame }) }
      }
      .frameReader { frame in
          buttonFrame = frame
      }
      ```
      */
-    @MainActor func present(anchoredTo anchorFrame: CGRect, customID: String? = nil, popupStackID: PopupStackID = .shared) async {
+    @MainActor func present(anchoredTo anchorFrameProvider: @escaping () -> CGRect, customID: String? = nil, popupStackID: PopupStackID = .shared) async {
         var popup = await AnyPopup(self)
         if let customID = customID {
             popup = await popup.updatedID(customID)
         }
-        popup = popup.updatedAnchorFrame(anchorFrame)
+        popup = popup.updatedAnchorFrameProvider(anchorFrameProvider)
         await PopupStack.fetch(id: popupStackID)?.modify(.insertPopup(popup))
     }
 }