Added more views and extensions.

Author: ivanvorobei

Package.swift

@@ -5,7 +5,7 @@ import PackageDescription
 let package = Package(
     name: "SwiftUIExtension",
     platforms: [
-        .iOS(.v14), 
+        .iOS(.v15), 
         .watchOS(.v6),
         .macOS(.v10_15)
     ],
@@ -16,13 +16,15 @@ let package = Package(
         )
     ],
     dependencies: [
-        .package(url: "https://github.com/sparrowcode/SwiftBoost", .upToNextMajor(from: "4.0.8"))
+        .package(url: "https://github.com/sparrowcode/SwiftBoost", .upToNextMajor(from: "4.0.8")),
+        .package(url: "https://github.com/siteline/swiftui-introspect", .upToNextMajor(from: "1.2.0"))
     ],
     targets: [
         .target(
             name: "SwiftUIExtension",
             dependencies: [
-                .product(name: "SwiftBoost", package: "SwiftBoost")
+                .product(name: "SwiftBoost", package: "SwiftBoost"),
+                .product(name: "SwiftUIIntrospect", package: "swiftui-introspect")
             ],
             swiftSettings: [
                 .define("SWIFTUIEXTENSION_SPM")

Sources/SwiftUIExtension/Compability/ViewCompability.swift

@@ -2,6 +2,22 @@ import SwiftUI
 
 extension View {
 
+    public func scrollTargetBehaviorCompability() -> some View {
+        if #available(iOS 17.0, watchOS 10.0, macOS 14.0, *) {
+            return self.scrollTargetBehavior(.viewAligned)
+        } else {
+            return self
+        }
+    }
+    
+    public func baselineOffsetCompability(_ offeset: CGFloat) -> some View {
+        if #available(iOS 16.0, watchOS 9.0, macOS 13.0, *) {
+            return self.baselineOffset(offeset)
+        } else {
+            return self
+        }
+    }
+    
     public func fontWeightCompability(_ weight: Font.Weight) -> some View {
         if #available(iOS 16.0, watchOS 9.0, macOS 13.0, *) {
             return self.fontWeight(weight)

Sources/SwiftUIExtension/Extensions/ColorExtension.swift

@@ -1,12 +1,89 @@
 import SwiftUI
 import SwiftBoost
 
-extension View {
+extension Color {
+    
+    public init(hex string: String) {
+        var string: String = string.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
+        if string.hasPrefix("#") {
+            _ = string.removeFirst()
+        }
+        
+        // Double the last value if incomplete hex
+        if !string.count.isMultiple(of: 2), let last = string.last {
+            string.append(last)
+        }
+        
+        // Fix invalid values
+        if string.count > 8 {
+            string = String(string.prefix(8))
+        }
+        
+        // Scanner creation
+        let scanner = Scanner(string: string)
+        
+        var color: UInt64 = 0
+        scanner.scanHexInt64(&color)
+        
+        if string.count == 2 {
+            let mask = 0xFF
+            
+            let g = Int(color) & mask
+            
+            let gray = Double(g) / 255.0
+            
+            self.init(.sRGB, red: gray, green: gray, blue: gray, opacity: 1)
+            
+        } else if string.count == 4 {
+            let mask = 0x00FF
+            
+            let g = Int(color >> 8) & mask
+            let a = Int(color) & mask
+            
+            let gray = Double(g) / 255.0
+            let alpha = Double(a) / 255.0
+            
+            self.init(.sRGB, red: gray, green: gray, blue: gray, opacity: alpha)
+            
+        } else if string.count == 6 {
+            let mask = 0x0000FF
+            let r = Int(color >> 16) & mask
+            let g = Int(color >> 8) & mask
+            let b = Int(color) & mask
+            
+            let red = Double(r) / 255.0
+            let green = Double(g) / 255.0
+            let blue = Double(b) / 255.0
+            
+            self.init(.sRGB, red: red, green: green, blue: blue, opacity: 1)
+            
+        } else if string.count == 8 {
+            let mask = 0x000000FF
+            let r = Int(color >> 24) & mask
+            let g = Int(color >> 16) & mask
+            let b = Int(color >> 8) & mask
+            let a = Int(color) & mask
+            
+            let red = Double(r) / 255.0
+            let green = Double(g) / 255.0
+            let blue = Double(b) / 255.0
+            let alpha = Double(a) / 255.0
+            
+            self.init(.sRGB, red: red, green: green, blue: blue, opacity: alpha)
+            
+        } else {
+            self.init(.sRGB, red: 1, green: 1, blue: 1, opacity: 1)
+        }
+    }
+}
 
-    #if canImport(UIKit)
+
+extension View {
+    
+#if canImport(UIKit)
     @available(iOS 15.0, watchOS 8.0, *)
     public func foregroundColor(_ color: UIColor) -> some View {
         self.foregroundColor(.init(uiColor: color))
     }
-    #endif
+#endif
 }

Sources/SwiftUIExtension/Extensions/ImageExtension.swift

@@ -0,0 +1,24 @@
+import Foundation
+import SwiftUI
+
+extension Image {
+    
+    public static func load(url: URL, completion: @escaping (Image?) -> Void) {
+        DispatchQueue.global(qos: .background).async {
+            if let data = try? Data(contentsOf: url) {
+                
+                #if canImport(UIKit)
+                let songArtwork = UIImage(data: data) ?? UIImage()
+                completion(Image(uiImage: songArtwork))
+                #endif
+                
+                #if canImport(AppKit)
+                let songArtwork = NSImage(data: data) ?? NSImage()
+                completion(Image(nsImage: songArtwork))
+                #endif
+                
+                completion(nil)
+            }
+        }
+    }
+}

Sources/SwiftUIExtension/Extensions/PreviewDevice.swift

@@ -2,7 +2,19 @@ import SwiftUI
 
 extension PreviewDevice {
 
+    public static var iPhone16Pro: PreviewDevice {
+        PreviewDevice(rawValue: "iPhone 16 Pro")
+    }
+    
+    public static var iPadPro11: PreviewDevice {
+        PreviewDevice(rawValue: "iPad Pro 11-inch (M4)")
+    }
+    
     public static var visionPro: PreviewDevice {
         PreviewDevice(rawValue: "Apple Vision Pro")
     }
+    
+    public static var mac: PreviewDevice {
+        PreviewDevice(rawValue: "Mac")
+    }
 }

Sources/SwiftUIExtension/Extensions/SafeArea.swift

@@ -0,0 +1,37 @@
+import SwiftUI
+
+extension View {
+    
+    /**
+     Default value for `safeAreaInset` none zero — this wrapper drop all spaces.
+     */
+    public func safeAreaInsetNoneSpaced<Content: View>(edge: VerticalEdge, @ViewBuilder content: () -> Content) -> some View {
+        self
+            .safeAreaInset(edge: edge, spacing: .zero) {
+                content()
+            }
+    }
+}
+
+// MARK: - Environment
+
+extension EnvironmentValues {
+    
+    public var safeAreaInsets: EdgeInsets {
+        self[SafeAreaInsetsKey.self]
+    }
+}
+
+private struct SafeAreaInsetsKey: EnvironmentKey {
+    
+    static var defaultValue: EdgeInsets {
+        (UIApplication.shared.windows.first(where: { $0.isKeyWindow })?.safeAreaInsets ?? .zero).insets
+    }
+}
+
+private extension UIEdgeInsets {
+    
+    var insets: EdgeInsets {
+        EdgeInsets(top: top, leading: left, bottom: bottom, trailing: right)
+    }
+}

Sources/SwiftUIExtension/Extensions/SizeTracker.swift

@@ -0,0 +1,27 @@
+import SwiftUI
+
+public struct SizeTracker: ViewModifier {
+    
+    @Binding var size: CGSize
+    
+    public func body(content: Content) -> some View {
+        content.background(
+            GeometryReader { geometry in
+                Color.clear
+                    .onAppear {
+                        self.size = geometry.size
+                    }
+                    .onChange(of: geometry.size) { newSize in
+                        self.size = newSize
+                    }
+            }
+        )
+    }
+}
+
+extension View {
+    
+    public func sizeChanged(_ size: Binding<CGSize>) -> some View {
+        self.modifier(SizeTracker(size: size))
+    }
+}

Sources/SwiftUIExtension/Extensions/View+Fade.swift

@@ -0,0 +1,39 @@
+import SwiftUI
+
+extension View {
+    
+    public func fade(top: CGFloat? = nil, bottom: CGFloat? = nil) -> some View {
+        modifier(VerticalFade(top: top, bottom: bottom))
+    }
+}
+
+struct VerticalFade: ViewModifier {
+    
+    let top: CGFloat?
+    let bottom: CGFloat?
+    
+    func body(content: Content) -> some View {
+        content
+             .mask {
+                 VStack(spacing: .zero) {
+                     
+                     if let top {
+                         // Top Fade
+                         LinearGradient(colors: [Color.black.opacity(0), Color.black], startPoint: .top, endPoint: .bottom)
+                             .frame(height: top)
+                     }
+                     
+                     // Middle
+                     Rectangle()
+                         .fill(Color.black)
+                         .ignoresSafeArea()
+                     
+                     if let bottom {
+                         // Bottom Fade
+                         LinearGradient(colors: [Color.black, Color.black.opacity(0)], startPoint: .top, endPoint: .bottom)
+                             .frame(height: bottom)
+                     }
+                 }
+             }
+    }
+}

Sources/SwiftUIExtension/Extensions/View+If.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+extension View {
+    
+    @ViewBuilder public func `if`<Content: View>(_ condition: Bool, transform: (Self) -> Content) -> some View {
+        if condition {
+            transform(self)
+        } else {
+            self
+        }
+    }
+}

Sources/SwiftUIExtension/Extensions/View+Layout.swift

@@ -0,0 +1,56 @@
+import SwiftUI
+
+extension View {
+    
+    public func horizontalSystemPadding(to view: HorizontalSystemPadding.PaddingView) -> some View {
+        modifier(HorizontalSystemPadding(paddingView: view))
+    }
+    
+    public func readableMargins() -> some View {
+        self
+            .padding(.horizontal)
+            .frame(maxWidth: 414)
+    }
+}
+
+public struct HorizontalSystemPadding: ViewModifier {
+    
+    let paddingView: PaddingView
+    
+    var value: CGFloat {
+        switch horizontalSizeClass {
+        case .compact:
+            return 16
+        case .regular:
+            #if os(visionOS)
+            return 24
+            #else
+            return 20
+            #endif
+        default:
+            return 16
+        }
+    }
+    
+    @Environment(\.horizontalSizeClass) var horizontalSizeClass
+    
+    public func body(content: Content) -> some View {
+        switch paddingView {
+        case .scroll:
+            if #available(iOS 17.0, macOS 14.0, watchOS 10.0, *) {
+                content
+                    .contentMargins(.horizontal, value, for: .scrollContent)
+            } else {
+                content
+            }
+        case .view:
+            content.padding(.horizontal, value)
+        }
+    }
+    
+    public enum PaddingView {
+        
+        case scroll
+        case view
+    }
+}