voltra 1.4.1 → 2.0.0-rc.4

package/ios/app/VoltraModuleImpl.swift

@@ -1,331 +0,0 @@
-import ActivityKit
-import Compression
-import ExpoModulesCore
-import Foundation
-import os
-
-/// Implementation details for VoltraModule to keep the main module file clean
-public class VoltraModuleImpl {
-  private let liveActivityService = VoltraLiveActivityService()
-
-  public init() {
-    // Clean up data for widgets that are no longer installed
-    VoltraWidgetService.cleanupOrphanedData()
-  }
-
-  func isHeadless() -> Bool {
-    if Thread.isMainThread {
-      return UIApplication.shared.applicationState == .background
-    }
-    return DispatchQueue.main.sync {
-      UIApplication.shared.applicationState == .background
-    }
-  }
-
-  var pushNotificationsEnabled: Bool {
-    // Support both keys for compatibility with older plugin and new Voltra naming
-    let main = Bundle.main
-    return main.object(forInfoDictionaryKey: VoltraStorageKeys.enablePushNotifications) as? Bool ?? false
-  }
-
-  // MARK: - Lifecycle & Monitoring
-
-  func startMonitoring() {
-    // Note: Event bus subscription is handled by VoltraModule since it has access to sendEvent()
-    liveActivityService.startMonitoring(enablePush: pushNotificationsEnabled)
-  }
-
-  func stopMonitoring() {
-    VoltraEventBus.shared.unsubscribe()
-    liveActivityService.stopMonitoring()
-  }
-
-  // MARK: - Live Activities
-
-  func startLiveActivity(jsonString: String, options: StartVoltraOptions?) async throws -> String {
-    guard #available(iOS 16.2, *) else { throw VoltraModule.VoltraErrors.unsupportedOS }
-    guard VoltraLiveActivityService.areActivitiesEnabled() else {
-      throw VoltraModule.VoltraErrors.liveActivitiesNotEnabled
-    }
-
-    do {
-      // Compress JSON using brotli level 2
-      let compressedJson = try BrotliCompression.compress(jsonString: jsonString)
-      try validatePayloadSize(compressedJson, operation: "start")
-
-      let activityName = options?.activityName?.trimmingCharacters(in: .whitespacesAndNewlines)
-
-      // Extract staleDate and relevanceScore from options
-      let staleDate: Date? = {
-        if let staleDateMs = options?.staleDate {
-          return Date(timeIntervalSince1970: staleDateMs / 1000.0)
-        }
-        return nil
-      }()
-      let relevanceScore: Double = options?.relevanceScore ?? 0.0
-
-      let pushType = try resolvePushType(channelId: options?.channelId)
-
-      // Create request struct with compressed JSON
-      let createRequest = CreateActivityRequest(
-        activityId: activityName,
-        deepLinkUrl: options?.deepLinkUrl,
-        jsonString: compressedJson,
-        staleDate: staleDate,
-        relevanceScore: relevanceScore,
-        pushType: pushType,
-        endExistingWithSameName: true
-      )
-
-      // Create activity using service
-      return try await liveActivityService.createActivity(createRequest)
-    } catch {
-      VoltraLogger.module.error("startLiveActivity failed: \(error)")
-      throw mapError(error)
-    }
-  }
-
-  func updateLiveActivity(activityId: String, jsonString: String, options: UpdateVoltraOptions?) async throws {
-    guard #available(iOS 16.2, *) else { throw VoltraModule.VoltraErrors.unsupportedOS }
-
-    // Compress JSON using brotli level 2
-    let compressedJson = try BrotliCompression.compress(jsonString: jsonString)
-    try validatePayloadSize(compressedJson, operation: "update")
-
-    // Extract staleDate and relevanceScore from options
-    let staleDate: Date? = {
-      if let staleDateMs = options?.staleDate {
-        return Date(timeIntervalSince1970: staleDateMs / 1000.0)
-      }
-      return nil
-    }()
-    let relevanceScore: Double = options?.relevanceScore ?? 0.0
-
-    // Create update request struct with compressed JSON
-    let updateRequest = UpdateActivityRequest(
-      jsonString: compressedJson,
-      staleDate: staleDate,
-      relevanceScore: relevanceScore
-    )
-
-    do {
-      try await liveActivityService.updateActivity(byName: activityId, request: updateRequest)
-    } catch {
-      throw mapError(error)
-    }
-  }
-
-  func endLiveActivity(activityId: String, options: EndVoltraOptions?) async throws {
-    guard #available(iOS 16.2, *) else { throw VoltraModule.VoltraErrors.unsupportedOS }
-
-    // Convert dismissal policy options to ActivityKit type
-    let dismissalPolicy = convertToActivityKitDismissalPolicy(options?.dismissalPolicy)
-
-    do {
-      try await liveActivityService.endActivity(byName: activityId, dismissalPolicy: dismissalPolicy)
-    } catch {
-      throw mapError(error)
-    }
-  }
-
-  func endAllLiveActivities() async throws {
-    guard #available(iOS 16.2, *) else { throw VoltraModule.VoltraErrors.unsupportedOS }
-    await liveActivityService.endAllActivities()
-  }
-
-  func getLatestVoltraActivityId() -> String? {
-    guard #available(iOS 16.2, *) else { return nil }
-    return liveActivityService.getLatestActivity()?.id
-  }
-
-  func listVoltraActivityIds() -> [String] {
-    guard #available(iOS 16.2, *) else { return [] }
-    return liveActivityService.getAllActivities().map(\.id)
-  }
-
-  func isLiveActivityActive(name: String) -> Bool {
-    guard #available(iOS 16.2, *) else { return false }
-    return liveActivityService.isActivityActive(name: name)
-  }
-
-  func reloadLiveActivities(activityNames: [String]?) async throws {
-    guard #available(iOS 16.2, *) else { throw VoltraModule.VoltraErrors.unsupportedOS }
-
-    let activities = liveActivityService.getAllActivities()
-
-    for activity in activities {
-      // If activityNames is provided, only reload those specific activities
-      if let names = activityNames, !names.isEmpty {
-        guard names.contains(activity.attributes.name) else { continue }
-      }
-
-      do {
-        let newState = try VoltraAttributes.ContentState(
-          uiJsonData: activity.content.state.uiJsonData
-        )
-
-        await activity.update(
-          ActivityContent(
-            state: newState,
-            staleDate: nil,
-            relevanceScore: 0.0
-          )
-        )
-        VoltraLogger.activity.info("Reloaded Live Activity '\(activity.attributes.name)'")
-      } catch {
-        VoltraLogger.activity.error("Failed to reload Live Activity '\(activity.attributes.name)': \(error)")
-      }
-    }
-  }
-
-  // MARK: - Image Preloading
-
-  func preloadImages(images: [PreloadImageOptions]) async throws -> PreloadImagesResult {
-    try await VoltraImagePreload.preloadImages(images: images)
-  }
-
-  func clearPreloadedImages(keys: [String]?) async {
-    await VoltraImagePreload.clearPreloadedImages(keys: keys)
-  }
-
-  // MARK: - Widgets
-
-  func updateWidget(widgetId: String, jsonString: String, options: UpdateWidgetOptions?) async throws {
-    try VoltraWidgetService.setWidgetData(widgetId: widgetId, jsonString: jsonString, deepLinkUrl: options?.deepLinkUrl)
-
-    // Clear any scheduled timeline so single-entry data takes effect
-    VoltraWidgetService.removeTimeline(for: widgetId)
-
-    // Reload the widget timeline
-    VoltraWidgetService.reloadTimeline(for: widgetId)
-  }
-
-  func scheduleWidget(widgetId: String, timelineJson: String) async throws {
-    try VoltraWidgetService.setTimeline(widgetId: widgetId, timelineJson: timelineJson)
-
-    // Reload the widget timeline to pick up scheduled entries
-    VoltraWidgetService.reloadTimeline(for: widgetId)
-  }
-
-  func reloadWidgets(widgetIds: [String]?) async {
-    if let ids = widgetIds, !ids.isEmpty {
-      for widgetId in ids {
-        VoltraWidgetService.reloadTimeline(for: widgetId)
-      }
-    } else {
-      VoltraWidgetService.reloadAllTimelines()
-    }
-  }
-
-  func clearWidget(widgetId: String) async {
-    VoltraWidgetService.removeAllData(for: widgetId)
-    VoltraWidgetService.reloadTimeline(for: widgetId)
-  }
-
-  func clearAllWidgets() async {
-    VoltraWidgetService.removeAllWidgets()
-    VoltraWidgetService.reloadAllTimelines()
-  }
-
-  func getActiveWidgets() async throws -> [[String: String]] {
-    try await VoltraWidgetService.getActiveWidgets()
-  }
-
-  func setWidgetServerCredentials(token: String, headers: [String: String]?) {
-    VoltraWidgetService.setWidgetServerCredentials(token: token, headers: headers)
-  }
-
-  func clearWidgetServerCredentials() {
-    VoltraWidgetService.clearWidgetServerCredentials()
-  }
-
-  // MARK: - Private Helpers
-
-  private func mapError(_ error: Error) -> Error {
-    if let moduleError = error as? VoltraModule.VoltraErrors {
-      return moduleError
-    }
-
-    if let serviceError = error as? VoltraLiveActivityError {
-      switch serviceError {
-      case .unsupportedOS:
-        return VoltraModule.VoltraErrors.unsupportedOS
-      case .liveActivitiesNotEnabled:
-        return VoltraModule.VoltraErrors.liveActivitiesNotEnabled
-      case .notFound:
-        return VoltraModule.VoltraErrors.notFound
-      }
-    }
-    return VoltraModule.VoltraErrors.unexpectedError(error)
-  }
-
-  private func resolvePushType(channelId rawChannelId: String?) throws -> PushType? {
-    guard let rawChannelId else {
-      return pushNotificationsEnabled ? .token : nil
-    }
-
-    let channelId = rawChannelId.trimmingCharacters(in: .whitespacesAndNewlines)
-    guard !channelId.isEmpty else {
-      throw VoltraModule.VoltraErrors.unexpectedError(
-        NSError(
-          domain: "VoltraModule",
-          code: -20,
-          userInfo: [NSLocalizedDescriptionKey: "channelId must be a non-empty string."]
-        )
-      )
-    }
-
-    guard pushNotificationsEnabled else {
-      throw VoltraModule.VoltraErrors.unexpectedError(
-        NSError(
-          domain: "VoltraModule",
-          code: -21,
-          userInfo: [NSLocalizedDescriptionKey: "channelId requires enablePushNotifications: true in the Voltra plugin config."]
-        )
-      )
-    }
-
-    if #available(iOS 18.0, *) {
-      return .channel(channelId)
-    }
-
-    // On iOS <18, broadcast channels are unavailable, so fall back to token-based updates.
-    return .token
-  }
-
-  private func validatePayloadSize(_ compressedPayload: String, operation: String) throws {
-    let dataSize = compressedPayload.utf8.count
-    let safeBudget = VoltraConstants.compressedPayloadSafeBudget
-    let hardCap = VoltraConstants.maxPayloadSizeBytes
-    VoltraLogger.module.debug("Compressed payload: \(dataSize)B (budget \(safeBudget)B, hard cap \(hardCap)B)")
-
-    if dataSize > safeBudget {
-      throw VoltraModule.VoltraErrors.unexpectedError(
-        NSError(
-          domain: "VoltraModule",
-          code: operation == "start" ? -10 : -11,
-          userInfo: [NSLocalizedDescriptionKey: "Compressed payload too large: \(dataSize)B (safe budget \(safeBudget)B, hard cap \(hardCap)B). Reduce the UI before \(operation == "start" ? "starting" : "updating") the Live Activity."]
-        )
-      )
-    }
-  }
-
-  private func convertToActivityKitDismissalPolicy(_ options: DismissalPolicyOptions?) -> ActivityUIDismissalPolicy {
-    guard let options = options else {
-      return .immediate
-    }
-
-    switch options.type {
-    case "immediate":
-      return .immediate
-    case "after":
-      if let timestamp = options.date {
-        let date = Date(timeIntervalSince1970: timestamp / 1000.0)
-        return .after(date)
-      }
-      return .immediate
-    default:
-      return .immediate
-    }
-  }
-}

package/ios/app/VoltraOptions.swift

@@ -1,72 +0,0 @@
-import ExpoModulesCore
-import Foundation
-
-/// Shared options for both startLiveActivity and updateLiveActivity
-public struct SharedVoltraOptions: Record {
-  /// Unix timestamp in milliseconds
-  @Field
-  public var staleDate: Double?
-
-  /// Double value between 0.0 and 1.0, defaults to 0.0
-  @Field
-  public var relevanceScore: Double?
-
-  public init() {}
-}
-
-/// Options for starting a Live Activity
-public struct StartVoltraOptions: Record {
-  /// The name of the Live Activity.
-  /// Allows you to rebind to the same activity on app restart.
-  @Field
-  public var activityName: String?
-
-  /// URL to open when the Live Activity is tapped.
-  @Field
-  public var deepLinkUrl: String?
-
-  /// Unix timestamp in milliseconds
-  @Field
-  public var staleDate: Double?
-
-  /// Double value between 0.0 and 1.0, defaults to 0.0
-  @Field
-  public var relevanceScore: Double?
-
-  /// Channel ID for broadcast push notifications (iOS 18+).
-  @Field
-  public var channelId: String?
-
-  public init() {}
-}
-
-/// Options for updating a Live Activity
-public typealias UpdateVoltraOptions = SharedVoltraOptions
-
-/// Options for ending a Live Activity
-public struct EndVoltraOptions: Record {
-  @Field
-  public var dismissalPolicy: DismissalPolicyOptions?
-
-  public init() {}
-}
-
-/// Dismissal policy options
-public struct DismissalPolicyOptions: Record {
-  @Field
-  public var type: String // "immediate" or "after"
-
-  @Field
-  public var date: Double? // timestamp for after
-
-  public init() {}
-}
-
-/// Options for updating a home screen widget
-public struct UpdateWidgetOptions: Record {
-  /// URL to open when the widget is tapped
-  @Field
-  public var deepLinkUrl: String?
-
-  public init() {}
-}

package/ios/app/VoltraRN.swift

@@ -1,66 +0,0 @@
-import ExpoModulesCore
-import os
-import SwiftUI
-import UIKit
-
-class VoltraRN: ExpoView {
-  private var hostingController: UIHostingController<AnyView>?
-  private var root: VoltraNode = .empty
-
-  /// Unique identifier for this view instance, used as 'source' in interaction events
-  private var viewId: String = UUID().uuidString
-
-  required init(appContext: AppContext? = nil) {
-    super.init(appContext: appContext)
-    clipsToBounds = true
-    setupHostingController()
-  }
-
-  private func setupHostingController() {
-    let view = Voltra(root: .empty, activityId: viewId)
-    let hostingController = UIHostingController(rootView: AnyView(view))
-    hostingController.view.backgroundColor = .clear
-    addSubview(hostingController.view)
-    self.hostingController = hostingController
-  }
-
-  override func layoutSubviews() {
-    super.layoutSubviews()
-    hostingController?.view.frame = bounds
-  }
-
-  func setViewId(_ id: String) {
-    guard !id.isEmpty else { return }
-    viewId = id
-    updateView()
-  }
-
-  func setPayload(_ jsonString: String) {
-    parseAndUpdatePayload(jsonString)
-  }
-
-  private func parseAndUpdatePayload(_ jsonString: String) {
-    do {
-      let json = try JSONValue.parse(from: jsonString)
-      root = VoltraNode.parse(from: json)
-    } catch {
-      VoltraLogger.module.error("Failed to parse payload in VoltraView: \(error)")
-      root = .empty
-    }
-
-    updateView()
-  }
-
-  private func updateView() {
-    hostingController?.view.removeFromSuperview()
-
-    // This is not the most performant way to update the view, but it's the easiest way to get the job done.
-    let newView = Voltra(root: root, activityId: viewId)
-    let newHostingController = UIHostingController(rootView: AnyView(newView))
-    newHostingController.view.backgroundColor = .clear
-    newHostingController.view.frame = bounds
-    addSubview(newHostingController.view)
-
-    hostingController = newHostingController
-  }
-}

package/ios/app/VoltraWidgetService.swift

@@ -1,154 +0,0 @@
-import Foundation
-import os
-import WidgetKit
-
-/// App-side facade for all widget operations.
-///
-/// Delegates persistence to `VoltraWidgetDefaults` and system reload notifications
-/// to `WidgetCenter`, so callers have a single collaborator and the storage layer
-/// can be swapped without touching orchestration code.
-///
-/// Note: `VoltraWidgetDefaults` intentionally remains in `ios/shared/` because the
-/// widget extension target reads from it directly — this service is app-target only.
-enum VoltraWidgetService {
-  // MARK: - Storage (write)
-
-  static func setWidgetData(widgetId: String, jsonString: String, deepLinkUrl: String?) throws {
-    try VoltraWidgetDefaults.setWidgetJson(jsonString, for: widgetId, deepLinkUrl: deepLinkUrl)
-    VoltraLogger.widget.info("Widget data stored for '\(widgetId)'")
-  }
-
-  static func setTimeline(widgetId: String, timelineJson: String) throws {
-    try VoltraWidgetDefaults.setTimeline(timelineJson, for: widgetId)
-    VoltraLogger.widget.info("Timeline stored for '\(widgetId)'")
-  }
-
-  // MARK: - Storage (remove)
-
-  static func removeAllData(for widgetId: String) {
-    VoltraWidgetDefaults.removeAllData(for: widgetId)
-  }
-
-  static func removeTimeline(for widgetId: String) {
-    VoltraWidgetDefaults.removeTimeline(for: widgetId)
-  }
-
-  static func removeAllWidgets() {
-    VoltraWidgetDefaults.removeAllWidgets()
-  }
-
-  // MARK: - Reload
-
-  static func reloadTimeline(for widgetId: String) {
-    WidgetCenter.shared.reloadTimelines(ofKind: "\(VoltraStorageKeys.widgetKindPrefix)\(widgetId)")
-    VoltraLogger.widget.info("Reloaded timeline for '\(widgetId)'")
-  }
-
-  static func reloadAllTimelines() {
-    WidgetCenter.shared.reloadAllTimelines()
-    VoltraLogger.widget.info("Reloaded all timelines")
-  }
-
-  // MARK: - Server credentials
-
-  /// Saves widget server credentials to the Keychain and reloads all widget timelines
-  /// so extensions can use them on the next fetch.
-  static func setWidgetServerCredentials(token: String, headers: [String: String]?) {
-    VoltraKeychainHelper.saveToken(token)
-    if let headers = headers {
-      VoltraKeychainHelper.saveHeaders(headers)
-    } else {
-      VoltraKeychainHelper.deleteHeaders()
-    }
-    VoltraLogger.widget.info("Server credentials saved")
-    reloadAllTimelines()
-  }
-
-  /// Clears widget server credentials from the Keychain and reloads all widget timelines.
-  static func clearWidgetServerCredentials() {
-    VoltraKeychainHelper.clearAll()
-    VoltraLogger.widget.info("Server credentials cleared")
-    reloadAllTimelines()
-  }
-
-  // MARK: - Query
-
-  /// Returns active widgets as dictionaries with `name`, `kind`, and `family` keys.
-  static func getActiveWidgets() async throws -> [[String: String]] {
-    try await withCheckedThrowingContinuation { continuation in
-      WidgetCenter.shared.getCurrentConfigurations { result in
-        switch result {
-        case let .success(widgetInfos):
-          let mapped = widgetInfos.map { widget -> [String: String] in
-            let prefix = VoltraStorageKeys.widgetKindPrefix
-            let name = widget.kind.hasPrefix(prefix)
-              ? String(widget.kind.dropFirst(prefix.count))
-              : widget.kind
-
-            return [
-              "name": name,
-              "kind": widget.kind,
-              "family": mapWidgetFamily(widget.family),
-            ]
-          }
-          continuation.resume(returning: mapped)
-        case let .failure(error):
-          continuation.resume(throwing: error)
-        }
-      }
-    }
-  }
-
-  /// Returns the set of widget IDs currently installed on the device.
-  /// Only IDs whose kind carries the Voltra prefix are included.
-  static func getInstalledWidgetIds() async throws -> Set<String> {
-    try await withCheckedThrowingContinuation { continuation in
-      WidgetCenter.shared.getCurrentConfigurations { result in
-        switch result {
-        case let .success(configs):
-          let ids = Set(configs.compactMap { config -> String? in
-            let prefix = VoltraStorageKeys.widgetKindPrefix
-            guard config.kind.hasPrefix(prefix) else { return nil }
-            return String(config.kind.dropFirst(prefix.count))
-          })
-          continuation.resume(returning: ids)
-        case let .failure(error):
-          continuation.resume(throwing: error)
-        }
-      }
-    }
-  }
-
-  // MARK: - Maintenance
-
-  /// Removes persisted data for any widget that is known to the app but no longer
-  /// installed on the device. Safe to call fire-and-forget from app startup.
-  static func cleanupOrphanedData() {
-    let knownWidgetIds = Bundle.main.object(forInfoDictionaryKey: VoltraStorageKeys.widgetIds) as? [String] ?? []
-    guard !knownWidgetIds.isEmpty else { return }
-
-    Task {
-      guard let installedIds = try? await getInstalledWidgetIds() else { return }
-
-      for widgetId in knownWidgetIds where !installedIds.contains(widgetId) {
-        VoltraWidgetDefaults.removeAllData(for: widgetId)
-        VoltraLogger.widget.info("Cleaned up orphaned data for '\(widgetId)'")
-      }
-    }
-  }
-
-  // MARK: - Private helpers
-
-  private static func mapWidgetFamily(_ family: WidgetFamily) -> String {
-    switch family {
-    case .systemSmall: return "systemSmall"
-    case .systemMedium: return "systemMedium"
-    case .systemLarge: return "systemLarge"
-    case .systemExtraLarge: return "systemExtraLarge"
-    case .accessoryCircular: return "accessoryCircular"
-    case .accessoryRectangular: return "accessoryRectangular"
-    case .accessoryInline: return "accessoryInline"
-    @unknown default: return "unknown"
-    }
-  }
-}

package/ios/shared/BrotliCompression.swift

@@ -1,81 +0,0 @@
-import Compression
-import Foundation
-
-public enum BrotliCompressionError: Error {
-  case encodingFailed
-  case compressionFailed(Int)
-  case base64DecodingFailed
-  case decompressionFailed
-  case stringConversionFailed
-}
-
-public enum BrotliCompression {
-  /// Compresses a JSON string using brotli compression and returns a base64-encoded string
-  /// - Parameter jsonString: The JSON string to compress
-  /// - Returns: Base64-encoded compressed data
-  /// - Throws: BrotliCompressionError if compression fails
-  public static func compress(jsonString: String) throws -> String {
-    guard let jsonData = jsonString.data(using: .utf8) else {
-      throw BrotliCompressionError.encodingFailed
-    }
-
-    let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: jsonData.count * 2)
-    defer { buffer.deallocate() }
-
-    // Compress using brotli level 2 (iOS only supports level 2)
-    let compressedSize = compression_encode_buffer(
-      buffer,
-      jsonData.count * 2,
-      jsonData.withUnsafeBytes { $0.baseAddress!.assumingMemoryBound(to: UInt8.self) },
-      jsonData.count,
-      nil,
-      COMPRESSION_BROTLI
-    )
-
-    guard compressedSize > 0 else {
-      throw BrotliCompressionError.compressionFailed(jsonData.count)
-    }
-
-    // Convert compressed data to base64 string
-    let compressedData = Data(bytes: buffer, count: compressedSize)
-    return compressedData.base64EncodedString()
-  }
-
-  /// Decompresses a base64-encoded brotli-compressed string
-  /// - Parameter base64String: Base64-encoded compressed data
-  /// - Returns: Decompressed JSON string
-  /// - Throws: BrotliCompressionError if decompression fails
-  public static func decompress(base64String: String) throws -> String {
-    // Decode base64 to Data
-    guard let compressedData = Data(base64Encoded: base64String) else {
-      throw BrotliCompressionError.base64DecodingFailed
-    }
-
-    // Estimate decompressed size (brotli typically compresses to 20-30% of original)
-    // Using 8x to ensure we have enough buffer space
-    let estimatedSize = compressedData.count * 8
-    let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: estimatedSize)
-    defer { buffer.deallocate() }
-
-    // Decompress using brotli algorithm
-    let decompressedSize = compression_decode_buffer(
-      buffer,
-      estimatedSize,
-      compressedData.withUnsafeBytes { $0.baseAddress!.assumingMemoryBound(to: UInt8.self) },
-      compressedData.count,
-      nil,
-      COMPRESSION_BROTLI
-    )
-
-    guard decompressedSize > 0 else {
-      throw BrotliCompressionError.decompressionFailed
-    }
-
-    // Convert decompressed data to String
-    let decompressedData = Data(bytes: buffer, count: decompressedSize)
-    guard let jsonString = String(data: decompressedData, encoding: .utf8) else {
-      throw BrotliCompressionError.stringConversionFailed
-    }
-    return jsonString
-  }
-}