Update Color implementation

Package.swift

@@ -110,7 +110,7 @@ let OpenSwiftUI_SPITestTarget = Target.testTarget(
         "OpenSwiftUI_SPI",
         // For ProtocolDescriptor symbol linking
         "OpenSwiftUI",
-        .product(name: "Numerics", package: "swift-numerics")
+        .product(name: "Numerics", package: "swift-numerics"),
     ],
     exclude: ["README.md"],
     swiftSettings: sharedSwiftSettings
@@ -119,6 +119,7 @@ let openSwiftUICoreTestTarget = Target.testTarget(
     name: "OpenSwiftUICoreTests",
     dependencies: [
         "OpenSwiftUICore",
+        .product(name: "Numerics", package: "swift-numerics"),
     ],
     exclude: ["README.md"],
     swiftSettings: sharedSwiftSettings
@@ -133,6 +134,9 @@ let openSwiftUITestTarget = Target.testTarget(
 )
 let openSwiftUICompatibilityTestTarget = Target.testTarget(
     name: "OpenSwiftUICompatibilityTests",
+    dependencies: [
+        .product(name: "Numerics", package: "swift-numerics"),
+    ],
     exclude: ["README.md"],
     swiftSettings: sharedSwiftSettings
 )

Sources/OpenSwiftUICore/Data/Environment/EnvironmentalView.swift

@@ -0,0 +1,17 @@
+//
+//  EnvironmentalView.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+
+package protocol EnvironmentalView: PrimitiveView, UnaryView {
+    associatedtype EnvironmentBody: View
+    func body(environment: EnvironmentValues) -> EnvironmentBody
+}
+
+extension EnvironmentalView {
+    nonisolated public static func _makeView(view: _GraphValue<Self>, inputs: _ViewInputs) -> _ViewOutputs {
+        preconditionFailure("")
+    }
+}

Sources/OpenSwiftUICore/Graphic/Color/Color+CGColor.swift

@@ -0,0 +1,107 @@
+//
+//  Color+CoreGraphics.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Blocked by ResolvedGradient
+//  ID: A45C110C8134A7DB30776EFC6CE1E8A6 (SwiftUICore?)
+
+#if canImport(Darwin)
+
+public import CoreGraphics
+
+// MARK: - CGColor + Color
+
+extension Color {
+    /// Creates a color from a Core Graphics color.
+    ///
+    /// - Parameter color: A
+    ///   [CGColor](https://developer.apple.com/documentation/CoreGraphics/CGColor) instance
+    ///   from which to create a color.
+    @available(*, deprecated, message: "Use Color(cgColor:) when converting a CGColor, or create a standard Color directly")
+    public init(_ cgColor: CGColor) {
+        self.init(cgColor: cgColor)
+    }
+}
+
+extension Color {
+    /// Creates a color from a Core Graphics color.
+    ///
+    /// - Parameter color: A
+    ///   [CGColor](https://developer.apple.com/documentation/CoreGraphics/CGColor) instance
+    ///   from which to create a color.
+    public init(cgColor: CGColor) {
+        self.init(provider: cgColor)
+    }
+}
+
+extension CGColor: ColorProvider {
+    package func resolve(in environment: EnvironmentValues) -> Color.Resolved {
+        Color.Resolved(self)
+    }
+
+    package var staticColor: CGColor? {
+        self
+    }
+}
+
+extension Color.Resolved {
+    package static let srgb: CGColorSpace = CGColorSpace(name: CGColorSpace.sRGB)!
+    package static let srgbExtended: CGColorSpace = CGColorSpace(name: CGColorSpace.extendedSRGB)!
+    package static let srgbLinear: CGColorSpace = CGColorSpace(name: CGColorSpace.linearSRGB)!
+    package static let srgbExtendedLinear: CGColorSpace = CGColorSpace(name: CGColorSpace.extendedLinearSRGB)!
+    package static let displayP3: CGColorSpace = CGColorSpace(name: CGColorSpace.displayP3)!
+
+    package init(_ cgColor: CGColor) {
+        self = Color.Resolved(failableCGColor: cgColor) ?? .init(linearWhite: 0)
+    }
+
+    package init?(failableCGColor cgColor: CGColor) {
+        let colorSpace: Color.RGBColorSpace
+        let convertedColor: CGColor
+        switch cgColor.colorSpace {
+            case Color.Resolved.srgb, Color.Resolved.srgbExtended:
+                colorSpace = .sRGB
+                convertedColor = cgColor
+            case Color.Resolved.srgbLinear, Color.Resolved.srgbExtendedLinear:
+                colorSpace = .sRGBLinear
+                convertedColor = cgColor
+            case Color.Resolved.displayP3:
+                colorSpace = .displayP3
+                convertedColor = cgColor
+            default:
+                guard let color = cgColor.converted(to: Color.Resolved.srgbExtended, intent: .defaultIntent, options: nil) else {
+                    return nil
+                }
+                colorSpace = .sRGB
+                convertedColor = color
+        }
+        guard let components = convertedColor.components else {
+            return nil
+        }
+        let red = Float(components[0])
+        let green = Float(components[1])
+        let blue = Float(components[2])
+        let alpha = Float(cgColor.alpha)
+        self.init(colorSpace: colorSpace, red: red, green: green, blue: blue, opacity: alpha)
+    }
+}
+
+extension Color.Resolved {
+    private static let cache: ObjectCache<Color.Resolved, CGColor> = ObjectCache { resolved in
+        var components: [CGFloat] = [CGFloat(resolved.red), CGFloat(resolved.green), CGFloat(resolved.blue), CGFloat(resolved.opacity)]
+        return CGColor(colorSpace: Self.srgbExtended, components: &components)!
+    }
+
+    public var cgColor: CGColor {
+        Self.cache[self]
+    }
+}
+
+//extension ResolvedGradient {
+//  package var cgGradient: CGGradient? {
+//    get
+//  }
+//}
+
+#endif

Sources/OpenSwiftUICore/Graphic/Color/Color+ShapeStyle.swift

@@ -0,0 +1,72 @@
+//
+//  Color+ShapeStyle.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Complete
+
+package import Foundation
+
+extension Color: ShapeStyle {
+    package func fallbackColor(in env: EnvironmentValues) -> Color? { self }
+    package func resolvePaint(in environment: EnvironmentValues) -> Color.Resolved { resolve(in: environment) }
+
+    @available(*, deprecated, message: "obsolete")
+    @_alwaysEmitIntoClient
+    nonisolated public static func _makeView<S>(view: _GraphValue<_ShapeView<S, Self>>, inputs: _ViewInputs) -> _ViewOutputs where S: Shape {
+        _ShapeView<S, Self>._makeView(view: view, inputs: inputs)
+    }
+}
+
+extension ColorProvider {
+    package func apply(color: Color, to shape: inout _ShapeStyle_Shape) {
+        _apply(color: color, to: &shape)
+    }
+
+    package func _apply(color: Color, to shape: inout _ShapeStyle_Shape) {
+        switch shape.operation {
+            case let .prepareText(level):
+                if level >= 1 {
+                    let opacity = color.provider.opacity(at: level, environment: shape.environment)
+                    shape.result = .preparedText(.foregroundColor(color.opacity(Double(opacity))))
+                } else {
+                    shape.result = .preparedText(.foregroundColor(color))
+                }
+            case let .resolveStyle(name, levels):
+                guard levels.lowerBound != levels.upperBound else {
+                    return
+                }
+                let resolved = resolve(in: shape.environment)
+                let opacity = color.provider.opacity(at: levels.lowerBound, environment: shape.environment)
+
+                var newPack: _ShapeStyle_Pack
+                switch shape.result {
+                    case let .pack(pack): newPack = pack
+                    default: newPack = .init()
+                }
+                newPack[name, levels.lowerBound] = .init(.color(resolved.multiplyingOpacity(by: opacity)))
+                shape.result = .pack(newPack)
+            case let .fallbackColor(level):
+                if level >= 1 {
+                    let opacity = color.provider.opacity(at: level, environment: shape.environment)
+                    shape.result = .color(color.opacity(Double(opacity)))
+                } else {
+                    shape.result = .color(color)
+                }
+            default:
+                break
+        }
+    }
+}
+
+// MARK: - Color.Resolved + ResolvedPaint
+
+extension Color.Resolved: ResolvedPaint {
+    package func draw(path: Path, style: PathDrawingStyle, in context: GraphicsContext, bounds: CGRect?) {
+        context.draw(path, with: .color(self), style: style)
+    }
+
+    package var isClear: Bool { opacity == 0 }
+    package var isOpaque: Bool { opacity == 1 }
+    package static var leafProtobufTag: CodableResolvedPaint.Tag? { .color }
+}