Merge pull request #1300 from liveview-native/combined-attribute-resolution

`@LiveElement` macro API

Author: bcardarella

Sources/BuiltinRegistryGenerator/BuiltinRegistryGenerator.swift

@@ -27,9 +27,9 @@ struct BuiltinRegistryGenerator: ParsableCommand {
     ]
 
     static let additionalViews = [
-        "Capsule": "Shape(shape: Capsule(from: element))",
-        "Circle": "Shape(shape: Circle())",
-        "ContainerRelativeShape": "Shape(shape: ContainerRelativeShape())",
+        "Capsule": "Shape<R, Capsule>(shape: Capsule(from: element))",
+        "Circle": "Shape<R, Circle>(shape: Circle())",
+        "ContainerRelativeShape": "Shape<R, ContainerRelativeShape>(shape: ContainerRelativeShape())",
         "Divider": "Divider()",
         "EditButton": """
         #if os(iOS)
@@ -38,10 +38,10 @@ struct BuiltinRegistryGenerator: ParsableCommand {
         """,
         "Ellipse": "Ellipse()",
         "NamespaceContext": "NamespaceContext<R>()",
-        "Rectangle": "Shape(shape: Rectangle())",
+        "Rectangle": "Shape<R, Rectangle>(shape: Rectangle())",
         "RenameButton": "RenameButton()",
-        "RoundedRectangle": "Shape(shape: RoundedRectangle(from: element))",
-        "Color": "ColorView()",
+        "RoundedRectangle": "Shape<R, RoundedRectangle>(shape: RoundedRectangle(from: element))",
+        "Color": "ColorView<R>()",
         "Image": "ImageView<R>()",
         "phx-main": "PhxMain<R>()"
     ]

Sources/LiveViewNative/BuiltinRegistry+applyBinding.swift

@@ -8,47 +8,56 @@
 import SwiftUI
 import LiveViewNativeCore
 
+public enum _EventBinding: String {
+    case windowFocus = "phx-window-focus"
+    case windowBlur = "phx-window-blur"
+    case focus = "phx-focus"
+    case blur = "phx-blur"
+    case click = "phx-click"
+}
+
 extension BuiltinRegistry {
     @ViewBuilder
     static func applyBinding(
-        _ binding: AttributeName,
+        _ binding: _EventBinding,
         event: String,
         value: Payload,
         to view: some View,
         element: ElementNode
     ) -> some View {
         ProvidedBindingsReader(
-            binding: binding.rawValue,
+            binding: binding,
             content: view
         ) {
             switch binding {
-            case "phx-window-focus":
+            case .windowFocus:
                 ScenePhaseObserver(content: view, target: .active, type: "focus", event: event, value: value)
-            case "phx-window-blur":
+            case .windowBlur:
                 ScenePhaseObserver(content: view, target: .background, type: "blur", event: event, value: value)
-            case "phx-focus":
+            case .focus:
                 FocusObserver(content: view, target: true, type: "focus", event: event, value: value)
-            case "phx-blur":
+            case .blur:
                 FocusObserver(content: view, target: false, type: "blur", event: event, value: value)
-            case "phx-click":
+            case .click:
                 TapGestureView(content: view, type: "click", event: event, value: value)
-            default:
-                view
             }
         }
     }
 }
 
 /// A preference key that specifies what bindings the View handles internally.
 public enum _ProvidedBindingsKey: PreferenceKey {
-    public static var defaultValue: Set<String> { [] }
-    public static func reduce(value: inout Set<String>, nextValue: () -> Set<String>) {
+    public static var defaultValue: Set<_EventBinding> { [] }
+    public static func reduce(
+        value: inout Set<_EventBinding>,
+        nextValue: () -> Set<_EventBinding>
+    ) {
         value = nextValue()
     }
 }
 
 fileprivate struct ProvidedBindingsReader<Content: View, ApplyBinding: View>: View {
-    let binding: String
+    let binding: _EventBinding
     let content: Content
     @ViewBuilder let applyBinding: () -> ApplyBinding
     @State private var providesBinding: Bool = false

Sources/LiveViewNative/Environment.swift

@@ -50,15 +50,32 @@ private struct LiveContextStorageKey: EnvironmentKey {
 /// Provides access to ``LiveViewCoordinator`` properties via the environment.
 /// This exists to type-erase the coordinator, since environment properties can't be generic.
 struct CoordinatorEnvironment {
-    let pushEvent: @MainActor (String, String, Any, Int?) async throws -> Void
-    let elementChanged: (NodeRef) -> ObservableObjectPublisher
-    let document: Document
+    private final class Storage {
+        let pushEvent: @MainActor (String, String, Any, Int?) async throws -> Void
+        let elementChanged: @MainActor (NodeRef) -> ObservableObjectPublisher
+        let document: Document
+        
+        init<R: CustomRegistry>(_ coordinator: LiveViewCoordinator<R>, document: Document) {
+            self.pushEvent = coordinator.pushEvent
+            self.document = document
+            self.elementChanged = coordinator.elementChanged(_:)
+        }
+    }
+    private let storage: Storage
+    
+    var pushEvent: @MainActor (String, String, Any, Int?) async throws -> Void {
+        storage.pushEvent
+    }
+    var elementChanged: @MainActor (NodeRef) -> ObservableObjectPublisher {
+        storage.elementChanged
+    }
+    var document: Document {
+        storage.document
+    }
 
     @MainActor
     init<R: CustomRegistry>(_ coordinator: LiveViewCoordinator<R>, document: Document) {
-        self.pushEvent = coordinator.pushEvent
-        self.document = document
-        self.elementChanged = coordinator.elementChanged(_:)
+        self.storage = .init(coordinator, document: document)
     }
 
     fileprivate struct Key: EnvironmentKey {

Sources/LiveViewNative/Live/LiveElement.swift

@@ -0,0 +1,123 @@
+//
+//  LiveElement.swift
+//
+//
+//  Created by Carson Katri on 4/2/24.
+//
+
+import SwiftUI
+import LiveViewNativeCore
+
+@attached(member, names: named(liveElement), named(_TrackedContent))
+@attached(memberAttribute)
+public macro LiveElement() = #externalMacro(module: "LiveViewNativeMacros", type: "LiveElementMacro")
+
+@attached(accessor, names: named(get))
+public macro LiveAttribute(_ name: AttributeName? = nil) = #externalMacro(module: "LiveViewNativeMacros", type: "LiveAttributeMacro")
+
+@attached(accessor, names: named(willSet))
+public macro LiveElementIgnored() = #externalMacro(module: "LiveViewNativeMacros", type: "LiveElementIgnoredMacro")
+
+public protocol _LiveElementTrackedContent {
+    init()
+    init(from element: ElementNode) throws
+}
+
+@propertyWrapper public struct _LiveElementTracked<R: RootRegistry, T: _LiveElementTrackedContent>: DynamicProperty {
+    @ObservedElement public var element
+    @LiveContext<R> public var context
+    
+    public var wrappedValue: T
+    
+    public var projectedValue: Self {
+        self
+    }
+    
+    public init(wrappedValue: T) {
+        self.wrappedValue = wrappedValue
+    }
+    
+    public init(wrappedValue: T? = nil, element: ElementNode) {
+        self._element = .init(element: element)
+        self.wrappedValue = wrappedValue ?? (try? T.init(from: element)) ?? T.init()
+    }
+    
+    public mutating func update() {
+        self.wrappedValue = try! T.init(from: element)
+    }
+    
+    var isConstant: Bool {
+        _element.isConstant
+    }
+}
+
+public extension _LiveElementTracked {
+    func children(_ predicate: (Node) -> Bool = { node in
+        !node.attributes.contains(where: { $0.name.namespace == nil && $0.name.name == "template" })
+    }) -> some View {
+        context.coordinator.builder.fromNodes(_element.children.filter(predicate), context: context.storage)
+    }
+    
+    func children(in template: Template, default includeDefault: Bool = false) -> some View {
+        children {
+            $0.attributes.contains(where: {
+                $0 == template
+            }) || (includeDefault && !$0.attributes.contains(where: { $0.name.namespace == nil && $0.name.name == "template" }))
+        }
+    }
+    
+    func hasTemplate(_ template: Template, default includeDefault: Bool = false) -> Bool {
+        _element.children.contains(where: {
+            for attribute in $0.attributes {
+                if attribute == template {
+                    return true
+                } else if includeDefault && attribute.name.namespace == nil && attribute.name.name == "template" {
+                    return false
+                }
+            }
+            return includeDefault
+        })
+    }
+    
+    func hasTemplate(_ name: String, value: String) -> Bool {
+        hasTemplate(.init(name, value: value))
+    }
+    
+    var childNodes: [LiveViewNativeCore.Node] {
+        _element.children
+    }
+}
+
+public struct Template: RawRepresentable, ExpressibleByStringLiteral {
+    let name: String
+    let value: String?
+    
+    public init(_ name: String, value: String? = nil) {
+        self.name = name
+        self.value = value
+    }
+    
+    public init(rawValue: String) {
+        var components = rawValue.split(separator: "." as Character)
+        self.name = String(components.removeFirst())
+        self.value = components.isEmpty ? nil : components.joined(separator: ".")
+    }
+    
+    public init(stringLiteral value: String) {
+        self.init(rawValue: value)
+    }
+    
+    public var rawValue: String {
+        if let value {
+            return "\(name).\(value)"
+        } else {
+            return name
+        }
+    }
+    
+    static func == (_ lhs: LiveViewNativeCore.Attribute, _ rhs: Self) -> Bool {
+        lhs.name.namespace == nil
+            && lhs.name.name == "template"
+            && lhs.value == rhs.rawValue
+    }
+}

Sources/LiveViewNative/LiveErrorView.swift renamed to Sources/LiveViewNative/Live/LiveErrorView.swift

@@ -190,11 +190,7 @@ public struct LiveView<
                 AnyView(buildPhaseView(phase as! LiveViewPhase<R>))
             }
         }
-        .transformEnvironment(\.stylesheets) { stylesheets in
-            guard let stylesheet = session.stylesheet
-            else { return }
-            stylesheets[ObjectIdentifier(R.self)] = stylesheet
-        }
+        .environment(\.stylesheet, session.stylesheet ?? .init(content: [], classes: [:]))
         .environmentObject(session)
         .environmentObject(liveViewModel)
         .task {

Sources/LiveViewNative/LiveView.swift renamed to Sources/LiveViewNative/Live/LiveView.swift

@@ -2,7 +2,7 @@ import SwiftUI
 import LiveViewNative
 
 struct CatRatingView: View {
-    @Attribute("score") private var score: Int
+    @Attribute(.init(name: "score") private var score: Int
     @LiveContext<MyRegistry> private var context
 
     var body: some View {

Sources/LiveViewNative/LiveViewHost.swift renamed to Sources/LiveViewNative/Live/LiveViewHost.swift

@@ -2,7 +2,7 @@ import SwiftUI
 import LiveViewNative
 
 struct CatRatingView: View {
-    @Attribute("score") private var score: Int
+    @Attribute(.init(name: "score") private var score: Int
     @LiveContext<MyRegistry> private var context
     @State var editedScore: Int?
     @State var width: CGFloat = 0