Custom selectors (#233)

Author: davdroman

Sources/Introspect.swift

@@ -19,36 +19,23 @@ extension View {
         scope: IntrospectionScope? = nil,
         customize: @escaping (PlatformSpecificEntity) -> Void
     ) -> some View {
-        if platforms.contains(where: \.isCurrent) {
-            let id = IntrospectionAnchorID()
+        if let platform = platforms.first(where: \.isCurrent) {
+            let anchorID = IntrospectionAnchorID()
             self.background(
-                    IntrospectionAnchorView(
-                        id: id
-                    )
-                    .frame(width: 0, height: 0)
+                IntrospectionAnchorView(
+                    id: anchorID
                 )
-                .overlay(
-                    IntrospectionView(
-                        selector: { entity in
-                            let scope = scope ?? viewType.scope
-                            if
-                                scope.contains(.receiver),
-                                let target = entity.receiver(ofType: PlatformSpecificEntity.self, anchorID: id)
-                            {
-                                return target
-                            }
-                            if
-                                scope.contains(.ancestor),
-                                let target = entity.ancestor(ofType: PlatformSpecificEntity.self)
-                            {
-                                return target
-                            }
-                            return nil
-                        },
-                        customize: customize
-                    )
-                    .frame(width: 0, height: 0)
+                .frame(width: 0, height: 0)
+            )
+            .overlay(
+                IntrospectionView(
+                    selector: { entity in
+                        (platform.selector ?? .default)(entity, scope ?? viewType.scope, anchorID)
+                    },
+                    customize: customize
                 )
+                .frame(width: 0, height: 0)
+            )
         } else {
             self
         }
@@ -72,18 +59,15 @@ public protocol PlatformEntity: AnyObject {
 }
 
 extension PlatformEntity {
-    @_spi(Internals)
-    public var ancestors: some Sequence<Base> {
+    var ancestors: some Sequence<Base> {
         sequence(first: self~, next: { $0.ancestor~ }).dropFirst()
     }
 
-    @_spi(Internals)
-    public var allDescendants: [Base] {
+    var allDescendants: [Base] {
         self.descendants.reduce([self~]) { $0 + $1.allDescendants~ }
     }
 
-    @_spi(Internals)
-    public func nearestCommonAncestor(with other: Base) -> Base? {
+    func nearestCommonAncestor(with other: Base) -> Base? {
         var nearestAncestor: Base? = self~
 
         while let currentEntity = nearestAncestor, !other.isDescendant(of: currentEntity~) {
@@ -93,28 +77,24 @@ extension PlatformEntity {
         return nearestAncestor
     }
 
-    @_spi(Internals)
-    public func descendantsBetween(_ bottomEntity: Base, and topEntity: Base) -> [Base] {
-        var entered = false
+    func descendantsBetween(_ bottomEntity: Base, and topEntity: Base) -> [Base] {
         var result: [Base] = []
+        var entered = false
 
         for descendant in self.allDescendants {
             if descendant === bottomEntity {
                 entered = true
-                continue
-            }
-            if descendant === topEntity {
-                return result
-            }
-            if entered {
+            } else if descendant === topEntity {
+                break
+            } else if entered {
                 result.append(descendant)
             }
         }
 
         return result
     }
 
-    fileprivate func receiver<PlatformSpecificEntity: PlatformEntity>(
+    func receiver<PlatformSpecificEntity: PlatformEntity>(
         ofType type: PlatformSpecificEntity.Type,
         anchorID: IntrospectionAnchorID
     ) -> PlatformSpecificEntity? {
@@ -132,7 +112,7 @@ extension PlatformEntity {
             .first
     }
 
-    fileprivate func ancestor<PlatformSpecificEntity: PlatformEntity>(
+    func ancestor<PlatformSpecificEntity: PlatformEntity>(
         ofType type: PlatformSpecificEntity.Type
     ) -> PlatformSpecificEntity? {
         self.ancestors

Sources/IntrospectionSelector.swift

@@ -0,0 +1,57 @@
+@_spi(Internals)
+public struct IntrospectionSelector<Target: PlatformEntity> {
+    private let selector: (IntrospectionPlatformViewController, IntrospectionScope, IntrospectionAnchorID) -> Target?
+
+    static var `default`: Self { .from(Target.self, selector: { $0 }) }
+
+    @_spi(Internals)
+    public static func from<Entry: PlatformEntity>(_ entryType: Entry.Type, selector: @escaping (Entry) -> Target?) -> Self {
+        .init { controller, scope, anchorID in
+            guard let entity = { () -> (any PlatformEntity)? in
+                if Entry.Base.self == PlatformView.self {
+                    #if canImport(UIKit)
+                    if let introspectionView = controller.viewIfLoaded {
+                        return introspectionView
+                    }
+                    #elseif canImport(AppKit)
+                    if controller.isViewLoaded {
+                        return controller.view
+                    }
+                    #endif
+                } else if Entry.Base.self == PlatformViewController.self {
+                    return controller
+                }
+                return nil
+            }() else {
+                return nil
+            }
+            if
+                scope.contains(.receiver),
+                let entry = entity.receiver(ofType: Entry.self, anchorID: anchorID),
+                let target = selector(entry)
+            {
+                return target
+            }
+            if
+                scope.contains(.ancestor),
+                let entry = entity.ancestor(ofType: Entry.self),
+                let target = selector(entry)
+            {
+                return target
+            }
+            return nil
+        }
+    }
+
+    init(_ selector: @escaping (IntrospectionPlatformViewController, IntrospectionScope, IntrospectionAnchorID) -> Target?) {
+        self.selector = selector
+    }
+
+    func callAsFunction(
+        _ controller: IntrospectionPlatformViewController,
+        _ scope: IntrospectionScope,
+        _ anchorID: IntrospectionAnchorID
+    ) -> Target? {
+        selector(controller, scope, anchorID)
+    }
+}

Sources/IntrospectionView.swift

@@ -81,26 +81,11 @@ struct IntrospectionView<Target: PlatformEntity>: PlatformViewControllerRepresen
     private let customize: (Target) -> Void
 
     init(
-        selector: @escaping (any PlatformEntity) -> Target?,
+        selector: @escaping (IntrospectionPlatformViewController) -> Target?,
         customize: @escaping (Target) -> Void
     ) {
         self._observed = .constant(())
-        self.selector = { introspectionController in
-            if Target.Base.self == PlatformView.self {
-                #if canImport(UIKit)
-                if let introspectionView = introspectionController.viewIfLoaded {
-                    return selector(introspectionView)
-                }
-                #elseif canImport(AppKit)
-                if introspectionController.isViewLoaded {
-                    return selector(introspectionController.view)
-                }
-                #endif
-            } else if Target.Base.self == PlatformViewController.self {
-                return selector(introspectionController)
-            }
-            return nil
-        }
+        self.selector = selector
         self.customize = customize
     }
 

Sources/PlatformViewVersion.swift

@@ -1,32 +1,49 @@
 import SwiftUI
 
-public struct PlatformViewVersions<SwiftUIViewType: IntrospectableViewType, PlatformView> {
+public struct PlatformViewVersions<SwiftUIViewType: IntrospectableViewType, PlatformSpecificEntity: PlatformEntity> {
     let isCurrent: Bool
+    let selector: IntrospectionSelector<PlatformSpecificEntity>?
 
-    public static func iOS(_ versions: (iOSViewVersion<SwiftUIViewType, PlatformView>)...) -> Self {
-        Self(isCurrent: versions.contains(where: \.isCurrent))
+    private init<Version: PlatformVersion>(
+        _ versions: [PlatformViewVersion<Version, SwiftUIViewType, PlatformSpecificEntity>]
+    ) {
+        if let currentVersion = versions.first(where: \.isCurrent) {
+            self.isCurrent = true
+            self.selector = currentVersion.selector
+        } else {
+            self.isCurrent = false
+            self.selector = nil
+        }
     }
 
-    public static func tvOS(_ versions: (tvOSViewVersion<SwiftUIViewType, PlatformView>)...) -> Self {
-        Self(isCurrent: versions.contains(where: \.isCurrent))
+    public static func iOS(_ versions: (iOSViewVersion<SwiftUIViewType, PlatformSpecificEntity>)...) -> Self {
+        Self(versions)
     }
 
-    public static func macOS(_ versions: (macOSViewVersion<SwiftUIViewType, PlatformView>)...) -> Self {
-        Self(isCurrent: versions.contains(where: \.isCurrent))
+    public static func tvOS(_ versions: (tvOSViewVersion<SwiftUIViewType, PlatformSpecificEntity>)...) -> Self {
+        Self(versions)
+    }
+
+    public static func macOS(_ versions: (macOSViewVersion<SwiftUIViewType, PlatformSpecificEntity>)...) -> Self {
+        Self(versions)
     }
 }
 
-public typealias iOSViewVersion<SwiftUIViewType: IntrospectableViewType, PlatformView> = PlatformViewVersion<iOSVersion, SwiftUIViewType, PlatformView>
-public typealias tvOSViewVersion<SwiftUIViewType: IntrospectableViewType, PlatformView> = PlatformViewVersion<tvOSVersion, SwiftUIViewType, PlatformView>
-public typealias macOSViewVersion<SwiftUIViewType: IntrospectableViewType, PlatformView> = PlatformViewVersion<macOSVersion, SwiftUIViewType, PlatformView>
+public typealias iOSViewVersion<SwiftUIViewType: IntrospectableViewType, PlatformSpecificEntity: PlatformEntity> =
+    PlatformViewVersion<iOSVersion, SwiftUIViewType, PlatformSpecificEntity>
+public typealias tvOSViewVersion<SwiftUIViewType: IntrospectableViewType, PlatformSpecificEntity: PlatformEntity> =
+    PlatformViewVersion<tvOSVersion, SwiftUIViewType, PlatformSpecificEntity>
+public typealias macOSViewVersion<SwiftUIViewType: IntrospectableViewType, PlatformSpecificEntity: PlatformEntity> =
+    PlatformViewVersion<macOSVersion, SwiftUIViewType, PlatformSpecificEntity>
 
-public struct PlatformViewVersion<Version: PlatformVersion, SwiftUIViewType: IntrospectableViewType, PlatformView> {
+public struct PlatformViewVersion<Version: PlatformVersion, SwiftUIViewType: IntrospectableViewType, PlatformSpecificEntity: PlatformEntity> {
     let isCurrent: Bool
+    let selector: IntrospectionSelector<PlatformSpecificEntity>?
 }
 
 extension PlatformViewVersion {
-    @_spi(Internals) public init(for version: Version) {
-        self.init(isCurrent: version.isCurrent)
+    @_spi(Internals) public init(for version: Version, selector: IntrospectionSelector<PlatformSpecificEntity>? = nil) {
+        self.init(isCurrent: version.isCurrent, selector: selector)
     }
 
     @_spi(Internals) public static func unavailable(file: StaticString = #file, line: UInt = #line) -> Self {
@@ -43,6 +60,6 @@ extension PlatformViewVersion {
             https://github.com/siteline/swiftui-introspect/issues/new?title=`\(fileName):\(line)`+should+be+marked+unavailable
             """
         )
-        return Self(isCurrent: false)
+        return Self(isCurrent: false, selector: nil)
     }
 }