@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/StoreKit/StoreKit1.swift

@@ -0,0 +1,486 @@
+// StoreKit 1 (the original in-app purchase API), as code written against it
+// calls it: products requests, the payment queue and its transactions,
+// receipts. The browser has no App Store behind any of it: a products
+// request answers no products (every identifier comes back invalid),
+// `SKPaymentQueue.canMakePayments()` is false, a payment added to the queue
+// fails at once with `SKError.paymentNotAllowed`, restoring finds nothing,
+// and a receipt refresh fails with `SKError.unsupportedPlatform`. Observers
+// and delegates hear about all of it on the main actor's next turn, as
+// StoreKit calls them on the main thread. RevenueCat's StoreKit 1 path runs
+// against these, unchanged.
+//
+// The classes are `NSObject` subclasses, as in Apple's SDK, so they hash by
+// identity and can key dictionaries. The `@objc optional` protocol
+// requirements are ordinary requirements with default implementations
+// that do nothing.
+
+import Foundation
+
+// MARK: - Errors
+
+public let SKErrorDomain = "SKErrorDomain"
+
+/// A StoreKit 1 error: a code in `SKErrorDomain`, plus the user info.
+public struct SKError: CustomNSError, Hashable, @unchecked Sendable {
+    public enum Code: Int, Sendable, Hashable {
+        case unknown = 0
+        case clientInvalid = 1
+        case paymentCancelled = 2
+        case paymentInvalid = 3
+        case paymentNotAllowed = 4
+        case storeProductNotAvailable = 5
+        case cloudServicePermissionDenied = 6
+        case cloudServiceNetworkConnectionFailed = 7
+        case cloudServiceRevoked = 8
+        case privacyAcknowledgementRequired = 9
+        case unauthorizedRequestData = 10
+        case invalidOfferIdentifier = 11
+        case invalidSignature = 12
+        case missingOfferParams = 13
+        case invalidOfferPrice = 14
+        case overlayCancelled = 15
+        case overlayInvalidConfiguration = 16
+        case overlayTimeout = 17
+        case ineligibleForOffer = 18
+        case unsupportedPlatform = 19
+        case overlayPresentedInBackgroundScene = 20
+        case paymentMethodBindingConfigurationRequired = 21
+    }
+
+    public let code: Code
+    public let userInfo: [String: Any]
+
+    public init(_ code: Code, userInfo: [String: Any] = [:]) {
+        self.code = code
+        self.userInfo = userInfo
+    }
+
+    public init(_nsError error: NSError) {
+        code = Code(rawValue: error.code) ?? .unknown
+        userInfo = error.userInfo
+    }
+
+    public static var errorDomain: String { SKErrorDomain }
+    public var errorCode: Int { code.rawValue }
+    public var errorUserInfo: [String: Any] { userInfo }
+    public var localizedDescription: String {
+        (userInfo[NSLocalizedDescriptionKey] as? String) ?? "The operation couldn’t be completed. (SKErrorDomain error \(code.rawValue).)"
+    }
+
+    public static func == (lhs: SKError, rhs: SKError) -> Bool { lhs.code == rhs.code }
+    public func hash(into hasher: inout Hasher) { hasher.combine(code) }
+
+    public static var unknown: Code { .unknown }
+    public static var clientInvalid: Code { .clientInvalid }
+    public static var paymentCancelled: Code { .paymentCancelled }
+    public static var paymentInvalid: Code { .paymentInvalid }
+    public static var paymentNotAllowed: Code { .paymentNotAllowed }
+    public static var storeProductNotAvailable: Code { .storeProductNotAvailable }
+    public static var cloudServicePermissionDenied: Code { .cloudServicePermissionDenied }
+    public static var cloudServiceNetworkConnectionFailed: Code { .cloudServiceNetworkConnectionFailed }
+    public static var cloudServiceRevoked: Code { .cloudServiceRevoked }
+    public static var privacyAcknowledgementRequired: Code { .privacyAcknowledgementRequired }
+    public static var unauthorizedRequestData: Code { .unauthorizedRequestData }
+    public static var invalidOfferIdentifier: Code { .invalidOfferIdentifier }
+    public static var invalidSignature: Code { .invalidSignature }
+    public static var missingOfferParams: Code { .missingOfferParams }
+    public static var invalidOfferPrice: Code { .invalidOfferPrice }
+    public static var overlayCancelled: Code { .overlayCancelled }
+    public static var overlayInvalidConfiguration: Code { .overlayInvalidConfiguration }
+    public static var overlayTimeout: Code { .overlayTimeout }
+    public static var ineligibleForOffer: Code { .ineligibleForOffer }
+    public static var unsupportedPlatform: Code { .unsupportedPlatform }
+    public static var overlayPresentedInBackgroundScene: Code { .overlayPresentedInBackgroundScene }
+}
+
+/// `catch SKError.paymentCancelled`: matches an `SKError` with that code.
+public func ~= (code: SKError.Code, error: any Error) -> Bool {
+    (error as? SKError)?.code == code
+}
+
+/// Runs `body` on the main actor's next turn, as StoreKit calls its
+/// observers and delegates on the main thread later.
+func _onMainActorLater(_ body: @escaping @MainActor () -> Void) {
+    let box = _UncheckedBox(body)
+    Task { @MainActor in box.value() }
+}
+
+/// Carries a value the compiler cannot prove `Sendable` to the main actor;
+/// StoreKit's objects are only touched there.
+struct _UncheckedBox<Value>: @unchecked Sendable {
+    let value: Value
+    init(_ value: Value) { self.value = value }
+}
+
+// MARK: - Products
+
+/// A product the App Store sells. A products request in the browser finds
+/// none, so the only instances are the ones code makes itself (tests and
+/// previews subclass it and override the properties).
+open class SKProduct: NSObject {
+    public enum PeriodUnit: UInt, Sendable, Hashable {
+        case day = 0, week = 1, month = 2, year = 3
+    }
+
+    override public init() {}
+
+    open var localizedDescription: String { "" }
+    open var localizedTitle: String { "" }
+    open var price: NSDecimalNumber { .zero }
+    open var priceLocale: Locale { .current }
+    open var productIdentifier: String { "" }
+    open var isDownloadable: Bool { false }
+    open var downloadContentLengths: [NSNumber] { [] }
+    open var contentVersion: String { "" }
+    open var downloadContentVersion: String { "" }
+    open var isFamilyShareable: Bool { false }
+    open var subscriptionPeriod: SKProductSubscriptionPeriod? { nil }
+    open var introductoryPrice: SKProductDiscount? { nil }
+    open var subscriptionGroupIdentifier: String? { nil }
+    open var discounts: [SKProductDiscount] { [] }
+}
+
+/// How long a subscription period is.
+open class SKProductSubscriptionPeriod: NSObject {
+    override public init() {}
+    open var numberOfUnits: Int { 0 }
+    open var unit: SKProduct.PeriodUnit { .day }
+}
+
+/// An introductory or promotional price of a subscription.
+open class SKProductDiscount: NSObject {
+    public enum PaymentMode: UInt, Sendable, Hashable {
+        case payAsYouGo = 0, payUpFront = 1, freeTrial = 2
+    }
+
+    public enum `Type`: UInt, Sendable, Hashable {
+        case introductory = 0, subscription = 1
+    }
+
+    override public init() {}
+
+    open var price: NSDecimalNumber { .zero }
+    open var priceLocale: Locale { .current }
+    open var identifier: String? { nil }
+    open var subscriptionPeriod: SKProductSubscriptionPeriod { SKProductSubscriptionPeriod() }
+    open var numberOfPeriods: Int { 0 }
+    open var paymentMode: PaymentMode { .payAsYouGo }
+    open var type: `Type` { .introductory }
+}
+
+/// The store's region.
+open class SKStorefront: NSObject {
+    override public init() {}
+    open var countryCode: String { "" }
+    open var identifier: String { "" }
+}
+
+// MARK: - Requests
+
+/// What a request tells its delegate. Both methods are optional.
+public protocol SKRequestDelegate: NSObjectProtocol {
+    func requestDidFinish(_ request: SKRequest)
+    func request(_ request: SKRequest, didFailWithError error: any Error)
+}
+
+extension SKRequestDelegate {
+    public func requestDidFinish(_ request: SKRequest) {}
+    public func request(_ request: SKRequest, didFailWithError error: any Error) {}
+}
+
+/// A request to the App Store. `start()` answers on the main actor's next
+/// turn; `cancel()` before then means the delegate hears nothing.
+open class SKRequest: NSObject {
+    open weak var delegate: (any SKRequestDelegate)?
+    var cancelled = false
+
+    override public init() {}
+
+    open func start() {
+        cancelled = false
+        let request = _UncheckedBox(self)
+        _onMainActorLater {
+            guard !request.value.cancelled else { return }
+            request.value._answer()
+        }
+    }
+
+    open func cancel() { cancelled = true }
+
+    /// What the browser answers: subclasses say.
+    func _answer() { delegate?.requestDidFinish(self) }
+}
+
+/// What a products request found: in the browser, no products, and every
+/// identifier asked for among the invalid ones.
+open class SKProductsResponse: NSObject {
+    public let products: [SKProduct]
+    public let invalidProductIdentifiers: [String]
+
+    public init(products: [SKProduct], invalidProductIdentifiers: [String]) {
+        self.products = products
+        self.invalidProductIdentifiers = invalidProductIdentifiers
+    }
+
+    override public convenience init() { self.init(products: [], invalidProductIdentifiers: []) }
+}
+
+public protocol SKProductsRequestDelegate: SKRequestDelegate {
+    func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse)
+}
+
+/// Asks the App Store about products. The browser's store has none: the
+/// delegate gets an empty response, then `requestDidFinish`.
+open class SKProductsRequest: SKRequest {
+    let productIdentifiers: Set<String>
+
+    public init(productIdentifiers: Set<String>) {
+        self.productIdentifiers = productIdentifiers
+    }
+
+    override func _answer() {
+        let response = SKProductsResponse(products: [], invalidProductIdentifiers: productIdentifiers.sorted())
+        (delegate as? any SKProductsRequestDelegate)?.productsRequest(self, didReceive: response)
+        delegate?.requestDidFinish(self)
+    }
+}
+
+public let SKReceiptPropertyIsExpired = "expired"
+public let SKReceiptPropertyIsRevoked = "revoked"
+public let SKReceiptPropertyIsVolumePurchase = "vpp"
+
+/// Asks the App Store for a fresh receipt. There is no receipt in the
+/// browser: the delegate gets `SKError.unsupportedPlatform`.
+open class SKReceiptRefreshRequest: SKRequest {
+    public let receiptProperties: [String: Any]?
+
+    public init(receiptProperties properties: [String: Any]?) {
+        receiptProperties = properties
+    }
+
+    override public convenience init() { self.init(receiptProperties: nil) }
+
+    override func _answer() {
+        delegate?.request(self, didFailWithError: SKError(.unsupportedPlatform, userInfo: [NSLocalizedDescriptionKey: "The browser has no App Store receipt."]))
+    }
+}
+
+// MARK: - Payments
+
+/// A discount offer's signed parameters, attached to a payment.
+open class SKPaymentDiscount: NSObject {
+    public let identifier: String
+    public let keyIdentifier: String
+    public let nonce: UUID
+    public let signature: String
+    public let timestamp: NSNumber
+
+    public init(identifier: String, keyIdentifier: String, nonce: UUID, signature: String, timestamp: NSNumber) {
+        self.identifier = identifier
+        self.keyIdentifier = keyIdentifier
+        self.nonce = nonce
+        self.signature = signature
+        self.timestamp = timestamp
+    }
+}
+
+/// A request to buy a product.
+open class SKPayment: NSObject {
+    var _productIdentifier: String
+    var _quantity = 1
+    var _requestData: Data?
+    var _applicationUsername: String?
+    var _simulatesAskToBuyInSandbox = false
+    var _paymentDiscount: SKPaymentDiscount?
+
+    public init(product: SKProduct) {
+        _productIdentifier = product.productIdentifier
+    }
+
+    init(productIdentifier: String) {
+        _productIdentifier = productIdentifier
+    }
+
+    open var productIdentifier: String { _productIdentifier }
+    open var quantity: Int { _quantity }
+    open var requestData: Data? { _requestData }
+    open var applicationUsername: String? { _applicationUsername }
+    open var simulatesAskToBuyInSandbox: Bool { _simulatesAskToBuyInSandbox }
+    open var paymentDiscount: SKPaymentDiscount? { _paymentDiscount }
+}
+
+/// A payment whose details can be changed before it is added to the queue.
+open class SKMutablePayment: SKPayment {
+    override public init(product: SKProduct) { super.init(product: product) }
+
+    override open var productIdentifier: String {
+        get { _productIdentifier }
+        set { _productIdentifier = newValue }
+    }
+    override open var quantity: Int {
+        get { _quantity }
+        set { _quantity = newValue }
+    }
+    override open var requestData: Data? {
+        get { _requestData }
+        set { _requestData = newValue }
+    }
+    override open var applicationUsername: String? {
+        get { _applicationUsername }
+        set { _applicationUsername = newValue }
+    }
+    override open var simulatesAskToBuyInSandbox: Bool {
+        get { _simulatesAskToBuyInSandbox }
+        set { _simulatesAskToBuyInSandbox = newValue }
+    }
+    override open var paymentDiscount: SKPaymentDiscount? {
+        get { _paymentDiscount }
+        set { _paymentDiscount = newValue }
+    }
+}
+
+public enum SKPaymentTransactionState: Int, Sendable, Hashable {
+    case purchasing = 0, purchased = 1, failed = 2, restored = 3, deferred = 4
+}
+
+/// Content a purchase downloads from the App Store. Never any in the browser.
+open class SKDownload: NSObject {
+    override public init() {}
+    open var contentIdentifier: String { "" }
+    open var contentURL: URL? { nil }
+    open var error: (any Error)? { nil }
+}
+
+/// A payment in the queue. In the browser every one has failed.
+open class SKPaymentTransaction: NSObject {
+    let _payment: SKPayment
+    let _state: SKPaymentTransactionState
+    let _error: (any Error)?
+
+    init(payment: SKPayment, state: SKPaymentTransactionState, error: (any Error)?) {
+        _payment = payment
+        _state = state
+        _error = error
+    }
+
+    open var payment: SKPayment { _payment }
+    open var transactionState: SKPaymentTransactionState { _state }
+    open var error: (any Error)? { _error }
+    open var original: SKPaymentTransaction? { nil }
+    open var transactionDate: Date? { nil }
+    open var transactionIdentifier: String? { nil }
+    open var transactionReceipt: Data? { nil }
+    open var downloads: [SKDownload] { [] }
+}
+
+/// What the payment queue tells its observers. Only the first method is
+/// required.
+public protocol SKPaymentTransactionObserver: NSObjectProtocol {
+    func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction])
+    func paymentQueue(_ queue: SKPaymentQueue, removedTransactions transactions: [SKPaymentTransaction])
+    func paymentQueue(_ queue: SKPaymentQueue, restoreCompletedTransactionsFailedWithError error: any Error)
+    func paymentQueueRestoreCompletedTransactionsFinished(_ queue: SKPaymentQueue)
+    func paymentQueue(_ queue: SKPaymentQueue, updatedDownloads downloads: [SKDownload])
+    func paymentQueue(_ queue: SKPaymentQueue, shouldAddStorePayment payment: SKPayment, for product: SKProduct) -> Bool
+    func paymentQueueDidChangeStorefront(_ queue: SKPaymentQueue)
+    func paymentQueue(_ queue: SKPaymentQueue, didRevokeEntitlementsForProductIdentifiers productIdentifiers: [String])
+}
+
+extension SKPaymentTransactionObserver {
+    public func paymentQueue(_ queue: SKPaymentQueue, removedTransactions transactions: [SKPaymentTransaction]) {}
+    public func paymentQueue(_ queue: SKPaymentQueue, restoreCompletedTransactionsFailedWithError error: any Error) {}
+    public func paymentQueueRestoreCompletedTransactionsFinished(_ queue: SKPaymentQueue) {}
+    public func paymentQueue(_ queue: SKPaymentQueue, updatedDownloads downloads: [SKDownload]) {}
+    public func paymentQueue(_ queue: SKPaymentQueue, shouldAddStorePayment payment: SKPayment, for product: SKProduct) -> Bool { true }
+    public func paymentQueueDidChangeStorefront(_ queue: SKPaymentQueue) {}
+    public func paymentQueue(_ queue: SKPaymentQueue, didRevokeEntitlementsForProductIdentifiers productIdentifiers: [String]) {}
+}
+
+/// What the payment queue asks its delegate. Both methods are optional.
+public protocol SKPaymentQueueDelegate: NSObjectProtocol {
+    func paymentQueue(_ paymentQueue: SKPaymentQueue, shouldContinue transaction: SKPaymentTransaction, in newStorefront: SKStorefront) -> Bool
+    func paymentQueueShouldShowPriceConsent(_ paymentQueue: SKPaymentQueue) -> Bool
+}
+
+extension SKPaymentQueueDelegate {
+    public func paymentQueue(_ paymentQueue: SKPaymentQueue, shouldContinue transaction: SKPaymentTransaction, in newStorefront: SKStorefront) -> Bool { true }
+    public func paymentQueueShouldShowPriceConsent(_ paymentQueue: SKPaymentQueue) -> Bool { true }
+}
+
+/// The queue of payments. In the browser nothing can be paid for: a
+/// payment added to it becomes a failed transaction
+/// (`SKError.paymentNotAllowed`) that observers hear about and that stays in
+/// `transactions` until it is finished; restoring finishes at once with
+/// nothing restored. The storefront is unknown (nil).
+open class SKPaymentQueue: NSObject {
+    nonisolated(unsafe) static let shared = SKPaymentQueue()
+
+    open class func `default`() -> SKPaymentQueue { shared }
+
+    /// False: the browser has no App Store to pay through.
+    open class func canMakePayments() -> Bool { false }
+
+    open weak var delegate: (any SKPaymentQueueDelegate)?
+    open var storefront: SKStorefront? { nil }
+    open private(set) var transactions: [SKPaymentTransaction] = []
+    var observers: [any SKPaymentTransactionObserver] = []
+
+    override public init() {}
+
+    open var transactionObservers: [any SKPaymentTransactionObserver] { observers }
+
+    open func add(_ observer: any SKPaymentTransactionObserver) {
+        guard !observers.contains(where: { $0 === observer }) else { return }
+        observers.append(observer)
+    }
+
+    open func remove(_ observer: any SKPaymentTransactionObserver) {
+        observers.removeAll { $0 === observer }
+    }
+
+    /// Fails the payment: the browser cannot charge for anything.
+    open func add(_ payment: SKPayment) {
+        let error = SKError(.paymentNotAllowed, userInfo: [NSLocalizedDescriptionKey: "Purchases are not available in the browser."])
+        let transaction = SKPaymentTransaction(payment: payment, state: .failed, error: error)
+        transactions.append(transaction)
+        let box = _UncheckedBox((queue: self, transaction: transaction))
+        _onMainActorLater {
+            let (queue, transaction) = box.value
+            for observer in queue.observers { observer.paymentQueue(queue, updatedTransactions: [transaction]) }
+        }
+    }
+
+    /// Finds nothing to restore.
+    open func restoreCompletedTransactions() {
+        let queue = _UncheckedBox(self)
+        _onMainActorLater {
+            for observer in queue.value.observers { observer.paymentQueueRestoreCompletedTransactionsFinished(queue.value) }
+        }
+    }
+
+    open func restoreCompletedTransactions(withApplicationUsername username: String?) {
+        restoreCompletedTransactions()
+    }
+
+    /// Removes the transaction from the queue and tells the observers.
+    open func finishTransaction(_ transaction: SKPaymentTransaction) {
+        guard let index = transactions.firstIndex(where: { $0 === transaction }) else { return }
+        transactions.remove(at: index)
+        let box = _UncheckedBox((queue: self, transaction: transaction))
+        _onMainActorLater {
+            let (queue, transaction) = box.value
+            for observer in queue.observers { observer.paymentQueue(queue, removedTransactions: [transaction]) }
+        }
+    }
+
+    open func start(_ downloads: [SKDownload]) {}
+    open func pause(_ downloads: [SKDownload]) {}
+    open func resume(_ downloads: [SKDownload]) {}
+    open func cancel(_ downloads: [SKDownload]) {}
+
+    /// A no-op: there are no price increases to consent to.
+    open func showPriceConsentIfNeeded() {}
+
+    /// A no-op: the browser has no sheet for redeeming offer codes.
+    open func presentCodeRedemptionSheet() {}
+}