updating across the board for swift 5.8 layout, and annotated access to CG system components

Author: heckj

Package.swift

@@ -4,7 +4,6 @@
 import Foundation
 import PackageDescription
 
-
 let package = Package(
     name: "SwiftVizScale",
     platforms: [
@@ -33,7 +32,7 @@ let package = Package(
                 .product(name: "Collections", package: "swift-collections"),
             ],
             swiftSettings: [
-                .enableExperimentalFeature("StrictConcurrency")
+                .enableExperimentalFeature("StrictConcurrency"),
             ]
         ),
         .target(

Sources/SwiftVizScale/BandScale.swift

@@ -60,7 +60,7 @@ public struct BandScale<CategoryType: Comparable, OutputType: BinaryFloatingPoin
         self.paddingOuter = paddingOuter
         self.domain = domain
         self.reversed = reversed
-        if let from = from, let to = to {
+        if let from, let to {
             precondition(from < to, "attempting to set an inverted or empty range: \(from) to \(to)")
             rangeLower = from
             rangeHigher = to
@@ -71,7 +71,7 @@ public struct BandScale<CategoryType: Comparable, OutputType: BinaryFloatingPoin
     }
 
     // testing function only - verifies the scale is fully configured
-    internal func fullyConfigured() -> Bool {
+    func fullyConfigured() -> Bool {
         rangeLower != nil && rangeHigher != nil && domain.count > 0
     }
 
@@ -139,7 +139,7 @@ public struct BandScale<CategoryType: Comparable, OutputType: BinaryFloatingPoin
 
     // attributes of the scale when fully configured
 
-    internal func width() -> Double? {
+    func width() -> Double? {
         guard let from = rangeLower, let to = rangeHigher else {
             return nil
         }
@@ -163,7 +163,7 @@ public struct BandScale<CategoryType: Comparable, OutputType: BinaryFloatingPoin
         }
     }
 
-    internal func step() -> Double? {
+    func step() -> Double? {
         guard let width = width() else {
             return nil
         }
@@ -186,11 +186,10 @@ public struct BandScale<CategoryType: Comparable, OutputType: BinaryFloatingPoin
             // the value to be scaled isn't within the domain
             return nil
         }
-        let doublePosition: Double
-        if reversed {
-            doublePosition = Double(domain.reversed().firstIndex(of: value)!)
+        let doublePosition = if reversed {
+            Double(domain.reversed().firstIndex(of: value)!)
         } else {
-            doublePosition = Double(domain.firstIndex(of: value)!)
+            Double(domain.firstIndex(of: value)!)
         }
         let startLocation = Double(paddingOuter) + (doublePosition * step)
         let stopLocation = startLocation + width
@@ -243,11 +242,10 @@ public struct BandScale<CategoryType: Comparable, OutputType: BinaryFloatingPoin
         }
         // calculate the closest index
         let rangeExtentWithoutOuterPadding = Double(upperRange) - Double(lowerRange) - 2 * Double(paddingOuter)
-        let indexedRangeValue: Double
-        if reversed {
-            indexedRangeValue = (Double(upperRange) - Double(paddingOuter) - Double(location)) / rangeExtentWithoutOuterPadding
+        let indexedRangeValue: Double = if reversed {
+            (Double(upperRange) - Double(paddingOuter) - Double(location)) / rangeExtentWithoutOuterPadding
         } else {
-            indexedRangeValue = (Double(location) - Double(paddingOuter)) / rangeExtentWithoutOuterPadding
+            (Double(location) - Double(paddingOuter)) / rangeExtentWithoutOuterPadding
         }
         let rangeValueExpandedToCountDomain = indexedRangeValue * Double(domain.count - 1)
 
@@ -307,10 +305,10 @@ public extension BandScale {
     /// - Parameter formatter: An optional formatter to convert the domain values into strings.
     func defaultTickValues(formatter: Formatter? = nil) -> [String] {
         domain.map { value in
-            if let formatter = formatter {
-                return formatter.string(for: value) ?? ""
+            if let formatter {
+                formatter.string(for: value) ?? ""
             } else {
-                return String("\(value)")
+                String("\(value)")
             }
         }
     }

Sources/SwiftVizScale/Color/CGColor+hex.swift

@@ -83,7 +83,7 @@
         // MARK: - From CGColor to String
 
         func toHex(alpha: Bool = false) -> String? {
-            guard let components = components, components.count >= 3 else {
+            guard let components, components.count >= 3 else {
                 return nil
             }
 

Sources/SwiftVizScale/Color/LCH.swift

@@ -32,10 +32,12 @@
         // Color interpolation discussion:
         // https://www.alanzucconi.com/2016/01/06/colour-interpolation/
 
+        @MainActor
         static var lab = CGColorSpace(name: CGColorSpace.genericLab)!
 
         /// Creates a Core Graphics color instance from individual components in the LCH color space.
         /// - Parameter components: A list of four components in the order: Luminance, Chroma, Hue, and Alpha.
+        @MainActor
         public static func color(from components: [CGFloat]) -> CGColor {
             precondition(components.count == 4)
             var newComponents = components
@@ -56,6 +58,7 @@
         /// Returns a list of four components from a Core Graphics color instance, mapped into the LCH color space.
         ///
         /// The components, in order, are Luminance, Chroma, Hue, and Alpha.
+        @MainActor
         public static func components(from color: CGColor) -> [CGFloat] {
             // from https://mina86.com/2021/srgb-lab-lchab-conversions/
             // converting L,a*,b* to L,C,Hab (polar coordinate LAB color space)
@@ -95,6 +98,7 @@
         ///   - color2: The second color.
         ///   - t: A unit value between 0 and 1 representing the position between the first and second colors to return.
         /// - Returns: A color interpolated between the two colors you provide.
+        @MainActor
         public static func interpolate(_ color1: CGColor, _ color2: CGColor, t: CGFloat) -> CGColor {
             precondition(t >= 0 && t <= 1)
             let components1 = LCH.components(from: color1)
@@ -109,22 +113,21 @@
             // by +/- 2*PI to get a shorter distance.
             let hue1 = components1[2]
             let hue2 = components2[2]
-            let targetForInterpolation: CGFloat
-            if hue1 > hue2 {
+            let targetForInterpolation: CGFloat = if hue1 > hue2 {
                 // If the value for hue2 is greater than hue1, add 2*PI to hue2 and compare, choosing
                 // the shortest path for the target to which to interpolate.
                 if abs(hue1 - hue2) > abs(hue1 - (hue2 + 2 * Double.pi)) {
-                    targetForInterpolation = hue2 + 2 * Double.pi
+                    hue2 + 2 * Double.pi
                 } else {
-                    targetForInterpolation = hue2
+                    hue2
                 }
             } else {
                 // If the value for hue2 is less than hue1, subtract 2*PI to hue2 and compare, choosing
                 // the shortest path for the target to which to interpolate.
                 if abs(hue1 - hue2) > abs(hue1 - (hue2 - 2 * Double.pi)) {
-                    targetForInterpolation = hue2 + 2 * Double.pi
+                    hue2 + 2 * Double.pi
                 } else {
-                    targetForInterpolation = hue2
+                    hue2
                 }
             }