KM-13582 Move additional UI elements from PIA VPN to PIAUIKit and PIASwiftUI

Author: kp-diego-trevisan

LocalPackages/PIALibrary/Sources/PIALibrary/Util/Data+Compression.swift

@@ -25,10 +25,18 @@ import zlib
 
 private let compressionBlockSize = 16384
 
+enum CompressionError: Error {
+    case initialization
+    case processing
+    case memory
+    case underlying(Error)
+}
+
 extension Data {
     /// Compresses the data using zlib deflate algorithm.
-    /// - Returns: The compressed data, or nil if compression fails.
-    func deflated() -> Data? {
+    /// - Returns: The compressed data.
+    /// - Throws: A `CompressionError` if compression fails.
+    func deflated() throws(CompressionError) -> Data {
         guard !isEmpty else {
             return self
         }
@@ -40,7 +48,7 @@ extension Data {
         stream.total_out = 0
 
         guard deflateInit2_(&stream, Z_BEST_COMPRESSION, Z_DEFLATED, MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY, ZLIB_VERSION, Int32(MemoryLayout<z_stream>.size)) == Z_OK else {
-            return nil
+            throw CompressionError.initialization
         }
 
         defer {
@@ -50,43 +58,46 @@ extension Data {
         var compressed = Data(count: compressionBlockSize)
         var compressedSize = compressed.count
 
-        let result: Data? = withUnsafeBytes { (inputBytes: UnsafeRawBufferPointer) -> Data? in
-            guard let inputBaseAddress = inputBytes.bindMemory(to: UInt8.self).baseAddress else {
-                return nil
-            }
-            stream.next_in = UnsafeMutablePointer<UInt8>(mutating: inputBaseAddress)
-            stream.avail_in = uInt(count)
-
-            repeat {
-                if Int(stream.total_out) >= compressedSize {
-                    compressedSize += compressionBlockSize
-                    compressed.count = compressedSize
+        do {
+            return try withUnsafeBytes { (inputBytes: UnsafeRawBufferPointer) -> Data in
+                guard let inputBaseAddress = inputBytes.bindMemory(to: UInt8.self).baseAddress else {
+                    throw CompressionError.memory
                 }
+                stream.next_in = UnsafeMutablePointer<UInt8>(mutating: inputBaseAddress)
+                stream.avail_in = uInt(count)
 
-                let status = compressed.withUnsafeMutableBytes { (outputBytes: UnsafeMutableRawBufferPointer) -> Int32 in
-                    guard let outputBaseAddress = outputBytes.bindMemory(to: UInt8.self).baseAddress else {
-                        return Z_STREAM_ERROR
+                repeat {
+                    if Int(stream.total_out) >= compressedSize {
+                        compressedSize += compressionBlockSize
+                        compressed.count = compressedSize
                     }
-                    stream.next_out = outputBaseAddress.advanced(by: Int(stream.total_out))
-                    stream.avail_out = uInt(compressedSize - Int(stream.total_out))
-                    return deflate(&stream, Z_FINISH)
-                }
 
-                if status < 0 {
-                    return nil
-                }
-            } while stream.avail_out == 0
+                    let status = compressed.withUnsafeMutableBytes { (outputBytes: UnsafeMutableRawBufferPointer) -> Int32 in
+                        guard let outputBaseAddress = outputBytes.bindMemory(to: UInt8.self).baseAddress else {
+                            return Z_STREAM_ERROR
+                        }
+                        stream.next_out = outputBaseAddress.advanced(by: Int(stream.total_out))
+                        stream.avail_out = uInt(compressedSize - Int(stream.total_out))
+                        return deflate(&stream, Z_FINISH)
+                    }
 
-            compressed.count = Int(stream.total_out)
-            return compressed
-        }
+                    if status < 0 {
+                        throw CompressionError.processing
+                    }
+                } while stream.avail_out == 0
 
-        return result
+                compressed.count = Int(stream.total_out)
+                return compressed
+            }
+        } catch {
+            throw .underlying(error)
+        }
     }
 
     /// Decompresses the data using zlib inflate algorithm.
-    /// - Returns: The decompressed data, or nil if decompression fails.
-    func inflated() -> Data? {
+    /// - Returns: The decompressed data.
+    /// - Throws: A `CompressionError` if decompression fails.
+    func inflated() throws -> Data {
         guard !isEmpty else {
             return self
         }
@@ -100,7 +111,7 @@ extension Data {
         stream.total_out = 0
 
         guard inflateInit2_(&stream, MAX_WBITS, ZLIB_VERSION, Int32(MemoryLayout<z_stream>.size)) == Z_OK else {
-            return nil
+            throw CompressionError.initialization
         }
 
         defer {
@@ -111,9 +122,9 @@ extension Data {
         var decompressedSize = decompressed.count
         var done = false
 
-        let result: Data? = withUnsafeBytes { (inputBytes: UnsafeRawBufferPointer) -> Data? in
+        return try withUnsafeBytes { (inputBytes: UnsafeRawBufferPointer) -> Data in
             guard let inputBaseAddress = inputBytes.bindMemory(to: UInt8.self).baseAddress else {
-                return nil
+                throw CompressionError.memory
             }
             stream.next_in = UnsafeMutablePointer<UInt8>(mutating: inputBaseAddress)
             stream.avail_in = uInt(count)
@@ -136,22 +147,17 @@ extension Data {
                 if status == Z_STREAM_END {
                     done = true
                 } else if status != Z_OK {
-                    return nil
+                    throw CompressionError.processing
                 }
             }
 
-            guard inflateEnd(&stream) == Z_OK else {
-                return nil
-            }
-
             guard done else {
-                return nil
+                throw CompressionError.processing
             }
 
             decompressed.count = Int(stream.total_out)
             return decompressed
         }
-
-        return result
     }
 }
+

LocalPackages/PIALibrary/Tests/PIALibraryTests/DataCompressionTests.swift

@@ -28,78 +28,59 @@ import Foundation
 struct DataCompressionTests {
 
     @Test("Compress and decompress simple text")
-    func compressAndDecompressSimpleText() {
+    func compressAndDecompressSimpleText() throws {
         let original = "This is a test"
         let originalData = original.data(using: .utf8)!
+        let compressed = try originalData.deflated()
 
-        let compressed = originalData.deflated()
-        #expect(compressed != nil, "Compression should succeed")
-        // Note: Small strings may not compress smaller due to compression overhead
-
-        let decompressed = compressed!.inflated()
-        #expect(decompressed != nil, "Decompression should succeed")
-
-        let decompressedString = String(data: decompressed!, encoding: .utf8)
+        let decompressed = try compressed.inflated()
+        let decompressedString = String(data: decompressed, encoding: .utf8)
         #expect(decompressedString == original, "Decompressed string should match original")
     }
 
     @Test("Compress and decompress longer text")
-    func compressAndDecompressLongerText() {
-        let original = String(repeating: "The quick brown fox jumps over the lazy dog. ", count: 100)
+    func compressAndDecompressLongerText() throws {
+        let original = String(repeating: "The quick brown fox jumps over the lazy dog.", count: 100)
         let originalData = original.data(using: .utf8)!
+        let compressed = try originalData.deflated()
+        #expect(compressed.count < originalData.count, "Compressed data should be smaller for repetitive text")
 
-        let compressed = originalData.deflated()
-        #expect(compressed != nil, "Compression should succeed")
-        #expect(compressed!.count < originalData.count, "Compressed data should be smaller for repetitive text")
-
-        let decompressed = compressed!.inflated()
-        #expect(decompressed != nil, "Decompression should succeed")
-
-        let decompressedString = String(data: decompressed!, encoding: .utf8)
+        let decompressed = try compressed.inflated()
+        let decompressedString = String(data: decompressed, encoding: .utf8)
         #expect(decompressedString == original, "Decompressed string should match original")
     }
 
     @Test("Handle empty data")
-    func handleEmptyData() {
+    func handleEmptyData() throws {
         let emptyData = Data()
+        let compressed = try emptyData.deflated()
+        #expect(compressed.isEmpty, "Compressed empty data should be empty")
 
-        let compressed = emptyData.deflated()
-        #expect(compressed != nil, "Compression of empty data should return empty data")
-        #expect(compressed!.isEmpty, "Compressed empty data should be empty")
-
-        let decompressed = emptyData.inflated()
-        #expect(decompressed != nil, "Decompression of empty data should return empty data")
-        #expect(decompressed!.isEmpty, "Decompressed empty data should be empty")
+        let decompressed = try emptyData.inflated()
+        #expect(decompressed.isEmpty, "Decompressed empty data should be empty")
     }
 
     @Test("Compress binary data")
-    func compressBinaryData() {
+    func compressBinaryData() throws {
         let binaryData = Data([0x00, 0x01, 0x02, 0x03, 0xFF, 0xFE, 0xFD, 0xFC])
+        let compressed = try binaryData.deflated()
 
-        let compressed = binaryData.deflated()
-        #expect(compressed != nil, "Compression of binary data should succeed")
-
-        let decompressed = compressed!.inflated()
-        #expect(decompressed != nil, "Decompression should succeed")
+        let decompressed = try compressed.inflated()
         #expect(decompressed == binaryData, "Decompressed binary data should match original")
     }
 
     @Test("Handle large data")
-    func handleLargeData() {
-        // Create a large data set (1MB)
-        let largeData = Data(repeating: 0x42, count: 1024 * 1024)
-
-        let compressed = largeData.deflated()
-        #expect(compressed != nil, "Compression of large data should succeed")
-        #expect(compressed!.count < largeData.count, "Compressed large data should be much smaller")
+    func handleLargeData() throws {
+        let largeData = Data(repeating: 0x42, count: 1024 * 1024) // (1MB)
+        let compressed = try largeData.deflated()
+        #expect(compressed.count < largeData.count, "Compressed large data should be much smaller")
 
-        let decompressed = compressed!.inflated()
-        #expect(decompressed != nil, "Decompression should succeed")
+        let decompressed = try compressed.inflated()
         #expect(decompressed == largeData, "Decompressed large data should match original")
     }
 
     @Test("Round-trip compression maintains data integrity")
-    func roundTripCompressionIntegrity() {
+    func roundTripCompressionIntegrity() throws {
         let testStrings = [
             "Hello, World!",
             "1234567890",
@@ -110,10 +91,10 @@ struct DataCompressionTests {
 
         for testString in testStrings {
             let originalData = testString.data(using: .utf8)!
-            let compressed = originalData.deflated()
-            let decompressed = compressed?.inflated()
-            let result = String(data: decompressed!, encoding: .utf8)
+            let compressed = try originalData.deflated()
 
+            let decompressed = try compressed.inflated()
+            let result = String(data: decompressed, encoding: .utf8)
             #expect(result == testString, "Round-trip should preserve: \(testString)")
         }
     }

LocalPackages/PIAUI/README.md

@@ -0,0 +1,24 @@
+# PIAUI
+
+Shared UI components and design system for PIA VPN iOS/tvOS applications.
+
+## Libraries
+
+### PIADesignSystem
+Core design system containing colors, assets, and visual design tokens.
+
+### PIAUIKit
+UIKit-based reusable UI components including custom controls, views, and extensions.
+
+### PIASwiftUI
+SwiftUI-based reusable UI components.
+
+## Usage
+
+Import the specific library you need in your Swift files:
+
+```swift
+import PIADesignSystem
+import PIAUIKit
+import PIASwiftUI
+```

PIA VPN/UI/Loading/LoadingView.swift …AUI/Sources/PIASwiftUI/LoadingView.swiftPIA VPN/UI/Loading/LoadingView.swift renamed to LocalPackages/PIAUI/Sources/PIASwiftUI/LoadingView.swift PIA VPN/UI/Loading/LoadingView.swift renamed to LocalPackages/PIAUI/Sources/PIASwiftUI/LoadingView.swift

@@ -23,11 +23,16 @@
 import SwiftUI
 import UIKit
 
-struct LoadingView: View {
+public struct LoadingView: View {
+    private let image: Image
     @State private var isRotating = false
 
-    var body: some View {
-        Image(asset: Asset.Ui.piaSpinner)
+    public init(image: Image) {
+        self.image = image
+    }
+
+    public var body: some View {
+        image
             .resizable()
             .aspectRatio(contentMode: .fit)
             .rotationEffect(.degrees(isRotating ? 360 : 0))
@@ -43,18 +48,14 @@ struct LoadingView: View {
 }
 
 /// UIKit wrapper for LoadingView
-final class LoadingViewController: UIHostingController<LoadingView> {
-    init() {
-        super.init(rootView: LoadingView())
+public final class LoadingViewController: UIHostingController<LoadingView> {
+    public init(image: Image) {
+        super.init(rootView: LoadingView(image: image))
         view.backgroundColor = .clear
     }
 
     @available(*, unavailable)
-    required init?(coder aDecoder: NSCoder) {
+    public required init?(coder aDecoder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
 }
-
-#Preview {
-    LoadingView()
-}

LocalPackages/PIAUI/Sources/PIASwiftUI/PIASwiftUI.swift

@@ -23,24 +23,31 @@
 import UIKit
 
 public extension UIView {
-    
+
     func addConstaintsToSuperview(leadingOffset: CGFloat, trailingOffset: CGFloat, topOffset: CGFloat, bottomOffset: CGFloat) {
-        
-        guard superview != nil else {
-            return
-        }
-        
+        guard let superview = superview else { return }
+
         translatesAutoresizingMaskIntoConstraints = false
-        
-        leadingAnchor.constraint(equalTo: superview!.leadingAnchor,
-                                 constant: leadingOffset).isActive = true
-        trailingAnchor.constraint(equalTo: superview!.trailingAnchor,
-                                  constant: trailingOffset).isActive = true
-        
-        topAnchor.constraint(equalTo: superview!.topAnchor,
-                             constant: topOffset).isActive = true
-        bottomAnchor.constraint(equalTo: superview!.bottomAnchor,
-                                constant: bottomOffset).isActive = true
+
+        leadingAnchor.constraint(
+            equalTo: superview.leadingAnchor,
+            constant: leadingOffset
+        ).isActive = true
+
+        trailingAnchor.constraint(
+            equalTo: superview.trailingAnchor,
+            constant: trailingOffset
+        ).isActive = true
+
+        topAnchor.constraint(
+            equalTo: superview.topAnchor,
+            constant: topOffset
+        ).isActive = true
+
+        bottomAnchor.constraint(
+            equalTo: superview.bottomAnchor,
+            constant: bottomOffset
+        ).isActive = true
     }
 
 }