Adds support for web archive apis

Author: anglinb

Sources/SuperwallKit/Config/ConfigManager.swift

@@ -287,12 +287,16 @@ class ConfigManager {
             presentationSourceType: nil,
             retryCount: 6
           )
-          _ = try? await self.paywallManager.getPaywallViewController(
-            from: request,
-            isForPresentation: true,
-            isPreloading: true,
-            delegate: nil
-          )
+          
+          let shouldSkip = try? await self.paywallManager.preloadViaPaywallArchivalAndShouldSkipViewControllerCache(form: request)
+          if (shouldSkip != nil && shouldSkip == true) {
+            _ = try? await self.paywallManager.getPaywallViewController(
+              from: request,
+              isForPresentation: true,
+              isPreloading: true,
+              delegate: nil
+            )
+          }
         }
       }
     }

Sources/SuperwallKit/Debug/DebugViewController.swift

@@ -268,6 +268,7 @@ final class DebugViewController: UIViewController {
     let child = factory.makePaywallViewController(
       for: paywall,
       withCache: nil,
+      withPaywallArchivalManager: nil,
       delegate: nil
     )
     addChild(child)

Sources/SuperwallKit/Dependencies/DependencyContainer.swift

@@ -40,11 +40,14 @@ final class DependencyContainer {
   var purchaseController: PurchaseController!
   // swiftlint:enable implicitly_unwrapped_optional
   let productsFetcher = ProductsFetcherSK1()
+  
+  let paywallArchivalManager: PaywallArchivalManager
 
   init(
     purchaseController controller: PurchaseController? = nil,
     options: SuperwallOptions? = nil
   ) {
+    paywallArchivalManager = PaywallArchivalManager()
     purchaseController = controller ?? AutomaticPurchaseController(factory: self)
     receiptManager = ReceiptManager(
       delegate: productsFetcher,
@@ -161,6 +164,14 @@ extension DependencyContainer: CacheFactory {
   }
 }
 
+
+// MARK - PaywallArchivalManager
+extension DependencyContainer: PaywallArchivalManagerFactory {
+  func makePaywallArchivalManager() -> PaywallArchivalManager {
+    return self.paywallArchivalManager
+  }
+}
+
 // MARK: - DeviceInfofactory
 extension DependencyContainer: DeviceHelperFactory {
   func makeDeviceInfo() -> DeviceInfo {
@@ -202,6 +213,7 @@ extension DependencyContainer: ViewControllerFactory {
   func makePaywallViewController(
     for paywall: Paywall,
     withCache cache: PaywallViewControllerCache?,
+    withPaywallArchivalManager archivalManager: PaywallArchivalManager?,
     delegate: PaywallViewControllerDelegateAdapter?
   ) -> PaywallViewController {
     let messageHandler = PaywallMessageHandler(
@@ -221,7 +233,8 @@ extension DependencyContainer: ViewControllerFactory {
       factory: self,
       storage: storage,
       webView: webView,
-      cache: cache
+      cache: cache,
+      paywallArchivalManager: paywallArchivalManager
     )
 
     webView.delegate = paywallViewController

Sources/SuperwallKit/Dependencies/FactoryProtocols.swift

@@ -15,6 +15,7 @@ protocol ViewControllerFactory: AnyObject {
   func makePaywallViewController(
     for paywall: Paywall,
     withCache cache: PaywallViewControllerCache?,
+    withPaywallArchivalManager archivalManager: PaywallArchivalManager?,
     delegate: PaywallViewControllerDelegateAdapter?
   ) -> PaywallViewController
 
@@ -25,6 +26,10 @@ protocol CacheFactory: AnyObject {
   func makeCache() -> PaywallViewControllerCache
 }
 
+protocol PaywallArchivalManagerFactory: AnyObject {
+  func makePaywallArchivalManager() -> PaywallArchivalManager
+}
+
 protocol VariablesFactory: AnyObject {
   func makeJsonVariables(
     products: [ProductVariable]?,

Sources/SuperwallKit/Misc/RequestCoalescence.swift

@@ -0,0 +1,40 @@
+//
+//  RequestCoalleser.swift
+//  PaywallArchiveBuilder
+//
+//  Created by Brian Anglin on 4/26/24.
+//
+
+import Foundation
+
+public actor RequestCoalescence<Input: Identifiable, Output> {
+  private var tasks: [Int: [(Output) -> Void]] = [:]
+  
+  public init() {}
+  
+  public func get(input: Input, request: @escaping (Input) async -> Output) async -> Output {
+    if tasks[input.id.hashValue] != nil {
+      // If there's already a task in progress, wait for it to finish
+      return await withCheckedContinuation { continuation in
+        appendCompletion(for: input.id.hashValue) { output in
+          continuation.resume(returning: output)
+        }
+      }
+    } else {
+      // Start a new task if one isn't already in progress
+      tasks[input.id.hashValue] = []
+      let output = await request(input)
+      completeTasks(for: input.id.hashValue, with: output)
+      return output
+    }
+  }
+  
+  private func appendCompletion(for hashValue: Int, completion: @escaping (Output) -> Void) {
+    tasks[hashValue]?.append(completion)
+  }
+  
+  private func completeTasks(for hashValue: Int, with output: Output) {
+    tasks[hashValue]?.forEach { $0(output) }
+    tasks[hashValue] = nil
+  }
+}

Sources/SuperwallKit/Models/Paywall/Paywall.swift

@@ -110,6 +110,10 @@ struct Paywall: Decodable {
 
   /// The local notifications for the paywall, e.g. to notify the user of free trial expiry.
   var localNotifications: [LocalNotification]
+  
+  // A listing of all the filtes referenced in a paywall
+  // to be able to preload the whole paywall into a web archive
+  var manifest: ArchivalManifest?
 
   enum CodingKeys: String, CodingKey {
     case id
@@ -127,6 +131,7 @@ struct Paywall: Decodable {
     case localNotifications
     case computedPropertyRequests = "computedProperties"
     case surveys
+    case manifest
 
     case responseLoadStartTime
     case responseLoadCompleteTime
@@ -219,6 +224,8 @@ struct Paywall: Decodable {
       forKey: .computedPropertyRequests
     ) ?? []
     computedPropertyRequests = throwableComputedPropertyRequests.compactMap { try? $0.result.get() }
+    
+    manifest = try? values.decodeIfPresent(ArchivalManifest.self, forKey: .manifest)
   }
 
   private static func makeProducts(from productItems: [ProductItem]) -> [Product] {
@@ -269,7 +276,8 @@ struct Paywall: Decodable {
     onDeviceCache: OnDeviceCaching = .disabled,
     localNotifications: [LocalNotification] = [],
     computedPropertyRequests: [ComputedPropertyRequest] = [],
-    surveys: [Survey] = []
+    surveys: [Survey] = [],
+    manifest: ArchivalManifest? = nil
   ) {
     self.databaseId = databaseId
     self.identifier = identifier
@@ -297,6 +305,7 @@ struct Paywall: Decodable {
     self.computedPropertyRequests = computedPropertyRequests
     self.surveys = surveys
     self.products = Self.makeProducts(from: productItems)
+    self.manifest = manifest
   }
 
   func getInfo(

Sources/SuperwallKit/Models/Paywall/PaywallManifest.swift

@@ -0,0 +1,84 @@
+//
+//  File.swift
+//  
+//
+//  Created by Brian Anglin on 4/27/24.
+//
+
+import Foundation
+
+// What we get back from the API
+
+public enum ArchivalManifestUsage: Codable {
+  case always
+  case never
+  case ifAvailableOnPaywallOpen
+  
+  enum CodingKeys: String, CodingKey {
+    case always = "ALWAYS"
+    case never = "NEVER"
+    case ifAvailableOnPaywallOpen = "IF_AVAILABLE_ON_PAYWALL_OPEN"
+  }
+  
+  public init(from decoder: any Decoder) throws {
+    let container = try decoder.singleValueContainer()
+    let rawValue = try container.decode(String.self)
+    let gatingType = CodingKeys(rawValue: rawValue) ?? .ifAvailableOnPaywallOpen
+    switch gatingType {
+    case .always:
+      self = .always
+    case .never:
+      self = .never
+    case .ifAvailableOnPaywallOpen:
+      self = .ifAvailableOnPaywallOpen
+    }
+  }
+}
+
+public struct ArchivalManifest: Codable {
+  public var use: ArchivalManifestUsage
+  public var document: ArchivalManifestItem
+  public var resources: [ArchivalManifestItem]
+  public init(document: ArchivalManifestItem, resources: [ArchivalManifestItem], use: ArchivalManifestUsage) {
+    self.document = document
+    self.resources = resources
+    self.use = use
+  }
+}
+
+public struct ArchivalManifestItem: Codable, Identifiable {
+  public var id: String {
+    url.absoluteString
+  }
+  let url: URL
+  let mimeType: String
+  public init(url: URL, mimeType: String) {
+    self.url = url
+    self.mimeType = mimeType
+  }
+}
+
+// What we return when the item is downloaded
+
+struct ArchivalManifestDownloaded: Codable {
+  let document: ArchivalManifestItemDownloaded
+  let items: [ArchivalManifestItemDownloaded]
+  func toWebArchive() -> WebArchive {
+    var webArchive = WebArchive(resource: document.toWebArchiveResource())
+    for item in items {
+      webArchive.addSubresource(item.toWebArchiveResource())
+    }
+    return webArchive
+  }
+}
+
+
+public struct ArchivalManifestItemDownloaded: Codable {
+  let url: URL
+  let mimeType: String
+  let data: Data
+  let isMainDocument: Bool
+  func toWebArchiveResource() -> WebArchiveResource {
+    return WebArchiveResource(url: url, data: data, mimeType: mimeType)
+  }
+}

Sources/SuperwallKit/Models/Paywall/WebArchive.swift

@@ -0,0 +1,68 @@
+//
+//  File.swift
+//  
+//
+//  Created by Brian Anglin on 4/27/24.
+//
+
+import Foundation
+
+struct WebArchive: Encodable {
+  
+  enum CodingKeys: String, CodingKey {
+    case mainResource = "WebMainResource"
+    case webSubresources = "WebSubresources"
+  }
+  
+  let mainResource: WebArchiveMainResource
+  var webSubresources: [WebArchiveResource]
+  
+  init(resource: WebArchiveResource) {
+    self.mainResource = WebArchiveMainResource(baseResource: resource)
+    self.webSubresources = []
+  }
+  
+  mutating func addSubresource(_ subresource: WebArchiveResource) {
+    self.webSubresources.append(subresource)
+  }
+}
+struct WebArchiveResource: Encodable {
+  
+  enum CodingKeys: String, CodingKey {
+    case url = "WebResourceURL"
+    case data = "WebResourceData"
+    case mimeType = "WebResourceMIMEType"
+  }
+  
+  let url: URL
+  let data: Data
+  let mimeType: String
+  
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(url.absoluteString, forKey: .url)
+    try container.encode(data, forKey: .data)
+    try container.encode(mimeType, forKey: .mimeType)
+  }
+}
+struct WebArchiveMainResource: Encodable {
+  
+  enum CodingKeys: String, CodingKey {
+    case url = "WebResourceURL"
+    case data = "WebResourceData"
+    case mimeType = "WebResourceMIMEType"
+    case textEncodingName = "WebResourceTextEncodingName"
+    case frameName = "WebResourceFrameName"
+  }
+  
+  let baseResource: WebArchiveResource
+  
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(baseResource.url.absoluteString, forKey: .url)
+    try container.encode(baseResource.data, forKey: .data)
+    try container.encode(baseResource.mimeType, forKey: .mimeType)
+    try container.encode("UTF-8", forKey: .textEncodingName)
+    try container.encode("", forKey: .frameName)
+  }
+}