zkit-ui 2.0.4 → 2.0.6

package/expo-module.config.json

@@ -0,0 +1,11 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["NativeImagePreviewModule"],
+    "podspecPath": "zkit-ui.podspec",
+    "swiftModuleName": "zkit_ui"
+  },
+  "android": {
+    "modules": ["cn.fontree.zkit.ui.preview.NativeImagePreviewModule"]
+  }
+}

package/ios/NativeImagePreview/NativeImagePreviewImageLoader.swift

@@ -0,0 +1,73 @@
+import Foundation
+import UIKit
+#if canImport(SDWebImage)
+import SDWebImage
+#endif
+
+public protocol NativeImagePreviewImageLoading {
+    func loadImage(
+        _ url: URL,
+        placeholder: UIImage?,
+        imageView: UIImageView,
+        completion: @escaping (_ image: UIImage?) -> Void
+    )
+}
+
+public struct NativeImagePreviewURLSessionImageLoader: NativeImagePreviewImageLoading {
+    public init() {}
+
+    public func loadImage(
+        _ url: URL,
+        placeholder: UIImage?,
+        imageView: UIImageView,
+        completion: @escaping (UIImage?) -> Void
+    ) {
+        if let placeholder = placeholder {
+            imageView.image = placeholder
+        }
+
+        DispatchQueue.global(qos: .background).async {
+            guard let data = try? Data(contentsOf: url), let image = UIImage(data: data) else {
+                completion(nil)
+                return
+            }
+
+            DispatchQueue.main.async {
+                imageView.image = image
+                completion(image)
+            }
+        }
+    }
+}
+
+#if canImport(SDWebImage)
+struct NativeImagePreviewSDWebImageLoader: NativeImagePreviewImageLoading {
+    func loadImage(
+        _ url: URL,
+        placeholder: UIImage?,
+        imageView: UIImageView,
+        completion: @escaping (UIImage?) -> Void
+    ) {
+        imageView.sd_setImage(
+            with: url,
+            placeholderImage: placeholder,
+            options: [],
+            progress: nil
+        ) { image, _, _, _ in
+            DispatchQueue.main.async {
+                completion(image)
+            }
+        }
+    }
+}
+#endif
+
+public enum NativeImagePreviewImageLoaderFactory {
+    public static func makeDefault() -> NativeImagePreviewImageLoading {
+        #if canImport(SDWebImage)
+        return NativeImagePreviewSDWebImageLoader()
+        #else
+        return NativeImagePreviewURLSessionImageLoader()
+        #endif
+    }
+}

package/ios/NativeImagePreview/NativeImagePreviewImageViewInteraction.swift

@@ -0,0 +1,245 @@
+import ObjectiveC
+import UIKit
+
+extension UIImageView {
+    private struct NativeImagePreviewAnchorRegistration {
+        let previewGroupId: String
+        let index: Int
+    }
+
+    private final class NativeImagePreviewTapGestureRecognizer: UITapGestureRecognizer {
+        weak var fromViewController: UIViewController?
+        var dataSource: NativeImagePreviewDataSource?
+        var imageLoader: NativeImagePreviewImageLoading?
+        var initialIndex = 0
+        var previewGroupId: String?
+        var configuration = NativeImagePreviewViewerConfiguration()
+    }
+
+    private static var anchorRegistrationKey: UInt8 = 0
+    private static var gestureRecognizerKey: UInt8 = 0
+
+    private var topMostHostViewController: UIViewController? {
+        let keyWindow: UIWindow? = {
+            if #available(iOS 13.0, *) {
+                let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+                let activeScene = scenes.first(where: { $0.activationState == .foregroundActive }) ?? scenes.first
+                return activeScene?.windows.first(where: { $0.isKeyWindow }) ?? activeScene?.windows.first
+            } else {
+                return UIApplication.shared.windows.first(where: { $0.isKeyWindow }) ?? UIApplication.shared.windows.first
+            }
+        }()
+        guard let rootViewController = keyWindow?.rootViewController else { return nil }
+        return rootViewController.presentedViewController ?? rootViewController
+    }
+
+    public func setupNativeImagePreviewViewer(
+        configuration: NativeImagePreviewViewerConfiguration = NativeImagePreviewViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: NativeImagePreviewImageLoading? = nil,
+        previewGroupId: String? = nil
+    ) {
+        configureNativeImagePreviewViewer(
+            dataSource: NativeImagePreviewArrayDataSource(items: [.image(image)]),
+            initialIndex: 0,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            previewGroupId: previewGroupId
+        )
+    }
+
+    public func setupNativeImagePreviewViewer(
+        url: URL,
+        initialIndex: Int = 0,
+        placeholder: UIImage? = nil,
+        configuration: NativeImagePreviewViewerConfiguration = NativeImagePreviewViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: NativeImagePreviewImageLoading? = nil,
+        previewGroupId: String? = nil
+    ) {
+        configureNativeImagePreviewViewer(
+            dataSource: NativeImagePreviewArrayDataSource(items: [.imageURL(url, placeholder: placeholder)]),
+            initialIndex: initialIndex,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            previewGroupId: previewGroupId
+        )
+    }
+
+    public func setupNativeImagePreviewViewer(
+        images: [UIImage],
+        initialIndex: Int = 0,
+        configuration: NativeImagePreviewViewerConfiguration = NativeImagePreviewViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: NativeImagePreviewImageLoading? = nil,
+        previewGroupId: String? = nil
+    ) {
+        let items = images.map { NativeImagePreviewMediaItem.image($0) }
+        configureNativeImagePreviewViewer(
+            dataSource: NativeImagePreviewArrayDataSource(items: items),
+            initialIndex: initialIndex,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            previewGroupId: previewGroupId
+        )
+    }
+
+    public func setupNativeImagePreviewViewer(
+        urls: [URL],
+        initialIndex: Int = 0,
+        placeholder: UIImage? = nil,
+        configuration: NativeImagePreviewViewerConfiguration = NativeImagePreviewViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: NativeImagePreviewImageLoading? = nil,
+        previewGroupId: String? = nil
+    ) {
+        let items = urls.map { NativeImagePreviewMediaItem.imageURL($0, placeholder: placeholder) }
+        configureNativeImagePreviewViewer(
+            dataSource: NativeImagePreviewArrayDataSource(items: items),
+            initialIndex: initialIndex,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            previewGroupId: previewGroupId
+        )
+    }
+
+    public func setupNativeImagePreviewViewer(
+        dataSource: NativeImagePreviewDataSource,
+        initialIndex: Int = 0,
+        configuration: NativeImagePreviewViewerConfiguration = NativeImagePreviewViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: NativeImagePreviewImageLoading? = nil,
+        previewGroupId: String? = nil
+    ) {
+        configureNativeImagePreviewViewer(
+            dataSource: dataSource,
+            initialIndex: initialIndex,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            previewGroupId: previewGroupId
+        )
+    }
+
+    func removeNativeImagePreviewViewerInteraction() {
+        if let recognizer = nativeImagePreviewTapGestureRecognizer {
+            removeGestureRecognizer(recognizer)
+        }
+        nativeImagePreviewTapGestureRecognizer = nil
+
+        if let registration = nativeImagePreviewAnchorRegistration {
+            NativeImagePreviewSourceViewRegistry.shared.unregister(
+                self,
+                previewGroupId: registration.previewGroupId,
+                index: registration.index
+            )
+        }
+        nativeImagePreviewAnchorRegistration = nil
+    }
+
+    private func configureNativeImagePreviewViewer(
+        dataSource: NativeImagePreviewDataSource?,
+        initialIndex: Int,
+        configuration: NativeImagePreviewViewerConfiguration,
+        from viewController: UIViewController?,
+        imageLoader: NativeImagePreviewImageLoading?,
+        previewGroupId: String?
+    ) {
+        let recognizer = nativeImagePreviewTapGestureRecognizer ?? {
+            let recognizer = NativeImagePreviewTapGestureRecognizer(target: self, action: #selector(showNativeImagePreviewViewer(_:)))
+            recognizer.numberOfTouchesRequired = 1
+            recognizer.numberOfTapsRequired = 1
+            nativeImagePreviewTapGestureRecognizer = recognizer
+            return recognizer
+        }()
+
+        isUserInteractionEnabled = true
+        clipsToBounds = true
+
+        recognizer.dataSource = dataSource
+        recognizer.imageLoader = imageLoader
+        recognizer.initialIndex = initialIndex
+        recognizer.previewGroupId = previewGroupId
+        recognizer.configuration = configuration
+        recognizer.fromViewController = viewController
+
+        if recognizer.view !== self {
+            addGestureRecognizer(recognizer)
+        }
+
+        updateNativeImagePreviewAnchorRegistration(previewGroupId: previewGroupId, index: initialIndex)
+    }
+
+    private var nativeImagePreviewTapGestureRecognizer: NativeImagePreviewTapGestureRecognizer? {
+        get {
+            objc_getAssociatedObject(self, &Self.gestureRecognizerKey) as? NativeImagePreviewTapGestureRecognizer
+        }
+        set {
+            objc_setAssociatedObject(
+                self,
+                &Self.gestureRecognizerKey,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    private var nativeImagePreviewAnchorRegistration: NativeImagePreviewAnchorRegistration? {
+        get {
+            objc_getAssociatedObject(self, &Self.anchorRegistrationKey) as? NativeImagePreviewAnchorRegistration
+        }
+        set {
+            objc_setAssociatedObject(
+                self,
+                &Self.anchorRegistrationKey,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    @objc
+    private func showNativeImagePreviewViewer(_ recognizer: NativeImagePreviewTapGestureRecognizer) {
+        guard let sourceView = recognizer.view as? UIImageView else { return }
+        let resolvedImageLoader = recognizer.imageLoader ?? NativeImagePreviewImageLoaderFactory.makeDefault()
+        let viewerController = NativeImagePreviewViewerController(
+            sourceView: sourceView,
+            dataSource: recognizer.dataSource,
+            imageLoader: resolvedImageLoader,
+            configuration: recognizer.configuration,
+            initialIndex: recognizer.initialIndex,
+            previewGroupId: recognizer.previewGroupId
+        )
+
+        let rootViewController = recognizer.fromViewController ?? topMostHostViewController
+        let presenter = rootViewController.flatMap(topMostPresentedController(from:))
+        presenter?.present(viewerController, animated: false)
+    }
+
+    private func topMostPresentedController(from rootViewController: UIViewController) -> UIViewController {
+        var controller = rootViewController
+        while let presented = controller.presentedViewController {
+            controller = presented
+        }
+        return controller
+    }
+
+    private func updateNativeImagePreviewAnchorRegistration(previewGroupId: String?, index: Int) {
+        if let existing = nativeImagePreviewAnchorRegistration {
+            NativeImagePreviewSourceViewRegistry.shared.unregister(
+                self,
+                previewGroupId: existing.previewGroupId,
+                index: existing.index
+            )
+            nativeImagePreviewAnchorRegistration = nil
+        }
+
+        guard let previewGroupId = previewGroupId, previewGroupId.isEmpty == false else { return }
+        NativeImagePreviewSourceViewRegistry.shared.register(self, previewGroupId: previewGroupId, index: index)
+        nativeImagePreviewAnchorRegistration = NativeImagePreviewAnchorRegistration(previewGroupId: previewGroupId, index: index)
+    }
+}

package/ios/NativeImagePreview/NativeImagePreviewLayoutSupport.swift

@@ -0,0 +1,143 @@
+import UIKit
+
+struct NativeImagePreviewSharedElementGeometry {
+    let visibleFrameInWindow: CGRect
+    let contentFrameInVisibleBounds: CGRect
+    let cornerRadius: CGFloat
+}
+
+struct NativeImagePreviewSharedElementState {
+    let image: UIImage
+    let geometry: NativeImagePreviewSharedElementGeometry
+}
+
+extension CGRect {
+    func nativeImagePreviewPixelAligned(scale: CGFloat) -> CGRect {
+        guard scale > 0 else { return self }
+        return CGRect(
+            x: (origin.x * scale).rounded() / scale,
+            y: (origin.y * scale).rounded() / scale,
+            width: (size.width * scale).rounded() / scale,
+            height: (size.height * scale).rounded() / scale
+        )
+    }
+
+    func nativeImagePreviewApproximatelyEquals(_ other: CGRect, tolerance: CGFloat = 0.5) -> Bool {
+        abs(minX - other.minX) <= tolerance
+            && abs(minY - other.minY) <= tolerance
+            && abs(width - other.width) <= tolerance
+            && abs(height - other.height) <= tolerance
+    }
+}
+
+extension NativeImagePreviewSharedElementGeometry {
+    func nativeImagePreviewPixelAligned(scale: CGFloat) -> NativeImagePreviewSharedElementGeometry {
+        NativeImagePreviewSharedElementGeometry(
+            visibleFrameInWindow: visibleFrameInWindow.nativeImagePreviewPixelAligned(scale: scale),
+            contentFrameInVisibleBounds: contentFrameInVisibleBounds.nativeImagePreviewPixelAligned(scale: scale),
+            cornerRadius: (cornerRadius * scale).rounded() / scale
+        )
+    }
+
+    func approximatelyEquals(_ other: NativeImagePreviewSharedElementGeometry, tolerance: CGFloat = 0.5) -> Bool {
+        visibleFrameInWindow.nativeImagePreviewApproximatelyEquals(other.visibleFrameInWindow, tolerance: tolerance)
+            && contentFrameInVisibleBounds.nativeImagePreviewApproximatelyEquals(
+                other.contentFrameInVisibleBounds,
+                tolerance: tolerance
+            )
+            && abs(cornerRadius - other.cornerRadius) <= tolerance
+    }
+}
+
+extension NativeImagePreviewSharedElementState {
+    func approximatelyEquals(_ other: NativeImagePreviewSharedElementState, tolerance: CGFloat = 0.5) -> Bool {
+        geometry.approximatelyEquals(other.geometry, tolerance: tolerance)
+            && abs(image.size.width - other.image.size.width) <= tolerance
+            && abs(image.size.height - other.image.size.height) <= tolerance
+    }
+}
+
+extension UIView {
+    func pinToSuperviewEdges(
+        top: CGFloat = 0,
+        leading: CGFloat = 0,
+        trailing: CGFloat = 0,
+        bottom: CGFloat = 0
+    ) {
+        guard let superview = superview else { return }
+        translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            topAnchor.constraint(equalTo: superview.topAnchor, constant: top),
+            leadingAnchor.constraint(equalTo: superview.leadingAnchor, constant: leading),
+            trailingAnchor.constraint(equalTo: superview.trailingAnchor, constant: -trailing),
+            bottomAnchor.constraint(equalTo: superview.bottomAnchor, constant: -bottom),
+        ])
+    }
+
+    func pinToSuperviewEdges(inset: CGFloat) {
+        pinToSuperviewEdges(top: inset, leading: inset, trailing: inset, bottom: inset)
+    }
+
+    func frameInWindow() -> CGRect {
+        convert(bounds, to: nil)
+    }
+}
+
+extension UIImageView {
+    func imageContentFrameInWindow() -> CGRect {
+        guard let image = image else { return frameInWindow() }
+        guard image.size.width > 0, image.size.height > 0 else { return frameInWindow() }
+        guard bounds.width > 0, bounds.height > 0 else { return frameInWindow() }
+
+        let widthRatio = bounds.width / image.size.width
+        let heightRatio = bounds.height / image.size.height
+
+        let scale: CGFloat
+        switch contentMode {
+        case .scaleAspectFill:
+            scale = max(widthRatio, heightRatio)
+        default:
+            scale = min(widthRatio, heightRatio)
+        }
+
+        let contentSize = CGSize(
+            width: image.size.width * scale,
+            height: image.size.height * scale
+        )
+        let contentFrame = CGRect(
+            x: (bounds.width - contentSize.width) * 0.5,
+            y: (bounds.height - contentSize.height) * 0.5,
+            width: contentSize.width,
+            height: contentSize.height
+        )
+        return convert(contentFrame, to: nil)
+    }
+
+    func nativeImagePreviewSharedElementState(clippingFrameInWindow: CGRect? = nil) -> NativeImagePreviewSharedElementState? {
+        guard let image = image else { return nil }
+        guard image.size.width > 0, image.size.height > 0 else { return nil }
+
+        let clippingFrame = clippingFrameInWindow ?? frameInWindow()
+        guard clippingFrame.width > 0, clippingFrame.height > 0 else { return nil }
+
+        let contentFrame = imageContentFrameInWindow()
+        var visibleFrame = clippingFrame.intersection(contentFrame)
+        if visibleFrame.isNull || visibleFrame.isEmpty {
+            visibleFrame = clippingFrame
+        }
+
+        let geometry = NativeImagePreviewSharedElementGeometry(
+            visibleFrameInWindow: visibleFrame,
+            contentFrameInVisibleBounds: contentFrame.offsetBy(
+                dx: -visibleFrame.minX,
+                dy: -visibleFrame.minY
+            ),
+            cornerRadius: (clipsToBounds || layer.masksToBounds) ? layer.cornerRadius : 0
+        )
+        let scale = window?.screen.scale ?? UIScreen.main.scale
+        return NativeImagePreviewSharedElementState(
+            image: image,
+            geometry: geometry.nativeImagePreviewPixelAligned(scale: scale)
+        )
+    }
+}

package/ios/NativeImagePreview/NativeImagePreviewMedia.swift

@@ -0,0 +1,28 @@
+import UIKit
+
+public enum NativeImagePreviewMediaItem {
+    case image(UIImage?)
+    case imageURL(URL, placeholder: UIImage?)
+    case video(url: URL, poster: URL?)
+}
+
+public protocol NativeImagePreviewDataSource: AnyObject {
+    func numberOfItems() -> Int
+    func item(at index: Int) -> NativeImagePreviewMediaItem
+}
+
+public final class NativeImagePreviewArrayDataSource: NativeImagePreviewDataSource {
+    private let items: [NativeImagePreviewMediaItem]
+
+    public init(items: [NativeImagePreviewMediaItem]) {
+        self.items = items
+    }
+
+    public func numberOfItems() -> Int {
+        items.count
+    }
+
+    public func item(at index: Int) -> NativeImagePreviewMediaItem {
+        items[index]
+    }
+}

package/ios/NativeImagePreview/NativeImagePreviewSourceViewRegistry.swift

@@ -0,0 +1,80 @@
+import UIKit
+
+final class NativeImagePreviewSourceViewRegistry {
+    static let shared = NativeImagePreviewSourceViewRegistry()
+
+    private final class WeakImageView {
+        weak var value: UIImageView?
+
+        init(_ value: UIImageView) {
+            self.value = value
+        }
+    }
+
+    private var anchors: [String: [Int: WeakImageView]] = [:]
+
+    private init() {}
+
+    func register(_ imageView: UIImageView, previewGroupId: String, index: Int) {
+        cleanup()
+        var previewGroupAnchors = anchors[previewGroupId] ?? [:]
+        previewGroupAnchors[index] = WeakImageView(imageView)
+        anchors[previewGroupId] = previewGroupAnchors
+    }
+
+    func unregister(_ imageView: UIImageView, previewGroupId: String?, index: Int?) {
+        cleanup()
+        if let previewGroupId = previewGroupId {
+            remove(imageView, from: previewGroupId, index: index)
+        } else {
+            for previewGroupId in Array(anchors.keys) {
+                remove(imageView, from: previewGroupId, index: nil)
+            }
+        }
+        cleanup()
+    }
+
+    func sourceView(for previewGroupId: String, index: Int) -> UIImageView? {
+        cleanup()
+        guard
+            let imageView = anchors[previewGroupId]?[index]?.value,
+            let window = imageView.window,
+            !imageView.isHidden
+        else {
+            return nil
+        }
+
+        let frameInWindow = imageView.frameInWindow()
+        guard !frameInWindow.isEmpty, frameInWindow.intersects(window.bounds) else {
+            return nil
+        }
+
+        return imageView
+    }
+
+    private func remove(_ imageView: UIImageView, from previewGroupId: String, index: Int?) {
+        guard var previewGroupAnchors = anchors[previewGroupId] else { return }
+
+        if let index = index {
+            if let registeredView = previewGroupAnchors[index]?.value, registeredView === imageView {
+                previewGroupAnchors.removeValue(forKey: index)
+            }
+        } else {
+            previewGroupAnchors = previewGroupAnchors.filter { _, weakImageView in
+                guard let registeredView = weakImageView.value else { return false }
+                return registeredView !== imageView
+            }
+        }
+
+        anchors[previewGroupId] = previewGroupAnchors.isEmpty ? nil : previewGroupAnchors
+    }
+
+    private func cleanup() {
+        anchors = anchors.compactMapValues { previewGroupAnchors in
+            let activeAnchors = previewGroupAnchors.filter { _, weakImageView in
+                weakImageView.value != nil
+            }
+            return activeAnchors.isEmpty ? nil : activeAnchors
+        }
+    }
+}