segregate files

pedi-foods/Sources/PediFoods/Views/Main/StoreDetailSupport.swift

@@ -0,0 +1,164 @@
+import SwiftUI
+#if canImport(UIKit)
+import UIKit
+#endif
+
+struct CategoryHeaderOffsetPreferenceKey: PreferenceKey {
+    static let defaultValue: [String: CGFloat] = [:]
+
+    static func reduce(value: inout [String: CGFloat], nextValue: () -> [String: CGFloat]) {
+        value.merge(nextValue(), uniquingKeysWith: { _, new in new })
+    }
+}
+
+struct ScrollOffsetReader: View {
+    @Binding var offsetY: CGFloat
+
+    var body: some View {
+#if canImport(UIKit)
+        ScrollOffsetReaderRepresentable(offsetY: $offsetY)
+#else
+        Color.clear
+#endif
+    }
+}
+
+#if canImport(UIKit)
+struct ScrollOffsetReaderRepresentable: UIViewRepresentable {
+    @Binding var offsetY: CGFloat
+
+    func makeUIView(context: Context) -> OffsetProbeView {
+        let view = OffsetProbeView()
+        view.onOffsetChanged = { value in
+            if offsetY != value {
+                offsetY = value
+            }
+        }
+        return view
+    }
+
+    func updateUIView(_ uiView: OffsetProbeView, context: Context) {
+        uiView.onOffsetChanged = { value in
+            if offsetY != value {
+                offsetY = value
+            }
+        }
+    }
+}
+
+final class OffsetProbeView: UIView {
+    var onOffsetChanged: ((CGFloat) -> Void)?
+    private var observation: NSKeyValueObservation?
+    private weak var observedScrollView: UIScrollView?
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        attachIfNeeded()
+    }
+
+    override func didMoveToSuperview() {
+        super.didMoveToSuperview()
+        attachIfNeeded()
+    }
+
+    private func attachIfNeeded() {
+        guard observation == nil else { return }
+        guard observedScrollView == nil else { return }
+
+        if let scrollView = enclosingScrollView() ?? findScrollViewInWindow() {
+            observe(scrollView)
+            return
+        }
+
+        retryAttach()
+    }
+
+    private func observe(_ scrollView: UIScrollView) {
+        observedScrollView = scrollView
+        observation = scrollView.observe(\.contentOffset, options: [.new, .initial]) { [weak self, weak scrollView] _, change in
+            guard let self, let scrollView, let y = change.newValue?.y else { return }
+            let adjusted = max(0, y + scrollView.adjustedContentInset.top)
+            DispatchQueue.main.async {
+                self.onOffsetChanged?(adjusted)
+            }
+        }
+    }
+
+    private func retryAttach() {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
+            self?.attachIfNeeded()
+        }
+    }
+
+    private func enclosingScrollView() -> UIScrollView? {
+        var current: UIView? = self
+        while let view = current {
+            if let scrollView = view as? UIScrollView {
+                return scrollView
+            }
+            current = view.superview
+        }
+        return nil
+    }
+
+    private func findScrollViewInWindow() -> UIScrollView? {
+        guard let window else { return nil }
+        let targetPoint = convert(CGPoint(x: bounds.midX, y: bounds.midY), to: window)
+        return findScrollView(in: window, containing: targetPoint)
+    }
+
+    private func findScrollView(in root: UIView, containing point: CGPoint) -> UIScrollView? {
+        for subview in root.subviews.reversed() {
+            if let match = findScrollView(in: subview, containing: point) {
+                return match
+            }
+        }
+
+        if let scrollView = root as? UIScrollView {
+            let rectInWindow = scrollView.convert(scrollView.bounds, to: window)
+            if rectInWindow.contains(point) {
+                return scrollView
+            }
+        }
+
+        return nil
+    }
+
+    deinit {
+        observation?.invalidate()
+    }
+}
+#endif
+
+struct AsyncStoreImage: View {
+    let imageURL: String?
+
+    var body: some View {
+        Group {
+            if let imageURL,
+               let url = URL(string: imageURL) {
+                AsyncImage(url: url) { phase in
+                    switch phase {
+                    case .success(let image):
+                        image
+                            .resizable()
+                            .scaledToFill()
+                    default:
+                        fallback
+                    }
+                }
+            } else {
+                fallback
+            }
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .background(AppColors.brandSoft)
+        .clipped()
+    }
+
+    private var fallback: some View {
+        Image("placeholder-product")
+            .resizable()
+            .scaledToFill()
+    }
+}