@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/StoreKit/Products.swift

@@ -0,0 +1,280 @@
+// StoreKit 2's `Product`, as code that loads and buys products is written:
+// the product's properties, its subscription information and offers, the
+// purchase options and results. The browser has no App Store, so
+// `Product.products(for:)` finds none and no `Product` value is ever made;
+// the members are here for the code that would read one (RevenueCat's
+// StoreKit 2 path). Subscription statuses and intro-offer eligibility
+// questions answer "none" and "not eligible".
+
+import Foundation
+import UIKit
+
+/// A product the App Store sells. There are none in the browser.
+public struct Product: Identifiable, Hashable, Sendable {
+    public typealias ID = String
+
+    public struct ProductType: Hashable, Sendable, RawRepresentable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let consumable = ProductType(rawValue: "Consumable")
+        public static let nonConsumable = ProductType(rawValue: "Non-Consumable")
+        public static let nonRenewable = ProductType(rawValue: "Non-Renewing Subscription")
+        public static let autoRenewable = ProductType(rawValue: "Auto-Renewable Subscription")
+        public var localizedDescription: String { rawValue }
+    }
+
+    public let id: ID
+    public let type: ProductType
+    public let displayName: String
+    public let description: String
+    public let price: Decimal
+    public let displayPrice: String
+    public let isFamilyShareable: Bool
+    public let subscription: SubscriptionInfo?
+    public let jsonRepresentation: Data
+    public let priceFormatStyle: Decimal.FormatStyle.Currency
+
+    /// How to write a subscription period's unit ("month").
+    public var subscriptionPeriodUnitFormatStyle: SubscriptionPeriod.Unit.FormatStyle { .init() }
+
+    /// The App Store has no products for a web app: none are found.
+    public static func products<Identifiers: Collection>(for identifiers: Identifiers) async throws -> [Product] where Identifiers.Element == ID { [] }
+
+    /// Not reached in the browser (there are no products to buy); it would
+    /// fail with `Product.PurchaseError.productUnavailable`.
+    public func purchase(options: Set<PurchaseOption> = []) async throws -> PurchaseResult {
+        throw PurchaseError.productUnavailable
+    }
+
+    /// As `purchase(options:)`, near a scene (iOS 17).
+    @MainActor public func purchase<S: UIScene>(confirmIn scene: S, options: Set<PurchaseOption> = []) async throws -> PurchaseResult {
+        throw PurchaseError.productUnavailable
+    }
+
+    /// As `purchase(options:)`, over a view controller (iOS 18.2).
+    @MainActor public func purchase(confirmIn viewController: UIViewController, options: Set<PurchaseOption> = []) async throws -> PurchaseResult {
+        throw PurchaseError.productUnavailable
+    }
+
+    public var currentEntitlement: VerificationResult<Transaction>? { get async { nil } }
+    public var latestTransaction: VerificationResult<Transaction>? { get async { nil } }
+
+    public static func == (lhs: Product, rhs: Product) -> Bool { lhs.id == rhs.id }
+    public func hash(into hasher: inout Hasher) { hasher.combine(id) }
+
+    // MARK: Purchases
+
+    public enum PurchaseResult: Sendable {
+        case success(VerificationResult<Transaction>)
+        case userCancelled
+        case pending
+    }
+
+    public enum PurchaseError: LocalizedError, Hashable, Sendable {
+        case invalidQuantity, productUnavailable, purchaseNotAllowed, ineligibleForOffer
+        case invalidOfferIdentifier, invalidOfferPrice, invalidOfferSignature, missingOfferParameters
+    }
+
+    /// A purchase option: the parameters a purchase carries.
+    public struct PurchaseOption: Hashable, Sendable {
+        let name: String
+        let value: String
+
+        public static func appAccountToken(_ token: UUID) -> PurchaseOption { .init(name: "appAccountToken", value: token.uuidString) }
+        public static func quantity(_ quantity: Int) -> PurchaseOption { .init(name: "quantity", value: String(quantity)) }
+        public static func simulatesAskToBuyInSandbox(_ simulatesAskToBuy: Bool) -> PurchaseOption { .init(name: "simulatesAskToBuyInSandbox", value: String(simulatesAskToBuy)) }
+        public static func promotionalOffer(offerID: String, keyID: String, nonce: UUID, signature: Data, timestamp: Int) -> PurchaseOption {
+            .init(name: "promotionalOffer", value: "\(offerID)|\(keyID)|\(nonce)|\(signature.base64EncodedString())|\(timestamp)")
+        }
+        /// A promotional offer signed as a JWS (iOS 26): the options it takes.
+        public static func promotionalOffer(_ offerID: String, compactJWS: String) -> Set<PurchaseOption> { [.init(name: "promotionalOffer", value: "\(offerID)|\(compactJWS)")] }
+        public static func billingPlanType(_ type: SubscriptionInfo.BillingPlanType) -> PurchaseOption { .init(name: "billingPlanType", value: type.rawValue) }
+        public static func introductoryOfferEligibility(compactJWS: String) -> PurchaseOption { .init(name: "introductoryOfferEligibility", value: compactJWS) }
+        public static func winBackOffer(_ offer: SubscriptionOffer) -> PurchaseOption { .init(name: "winBackOffer", value: offer.id ?? "") }
+        public static func onStorefrontChange(shouldContinuePurchase: @escaping @Sendable (Storefront) -> Bool) -> PurchaseOption { .init(name: "onStorefrontChange", value: "") }
+        public static func custom(key: String, value: String) -> PurchaseOption { .init(name: key, value: value) }
+        public static func custom(key: String, value: Bool) -> PurchaseOption { .init(name: key, value: String(value)) }
+        public static func custom(key: String, value: Double) -> PurchaseOption { .init(name: key, value: String(value)) }
+        public static func custom(key: String, value: Data) -> PurchaseOption { .init(name: key, value: value.base64EncodedString()) }
+    }
+
+    // MARK: Subscriptions
+
+    public struct SubscriptionPeriod: Hashable, Sendable {
+        public enum Unit: Hashable, Sendable, CaseIterable {
+            case day, week, month, year
+            public var localizedDescription: String { "\(self)" }
+
+            /// The unit's name ("month"), as `formatted(product.subscriptionPeriodUnitFormatStyle)` writes it.
+            public struct FormatStyle: Foundation.FormatStyle, Hashable, Sendable {
+                public init() {}
+                public func format(_ value: Unit) -> String { "\(value)" }
+            }
+
+            public func formatted(_ style: FormatStyle) -> String { style.format(self) }
+        }
+
+        public let unit: Unit
+        public let value: Int
+
+        init(unit: Unit, value: Int) {
+            self.unit = unit
+            self.value = value
+        }
+
+        public static let weekly = SubscriptionPeriod(unit: .week, value: 1)
+        public static let monthly = SubscriptionPeriod(unit: .month, value: 1)
+        public static let everyTwoMonths = SubscriptionPeriod(unit: .month, value: 2)
+        public static let everyThreeMonths = SubscriptionPeriod(unit: .month, value: 3)
+        public static let everySixMonths = SubscriptionPeriod(unit: .month, value: 6)
+        public static let yearly = SubscriptionPeriod(unit: .year, value: 1)
+    }
+
+    public struct SubscriptionOffer: Hashable, Sendable {
+        public struct OfferType: Hashable, Sendable, RawRepresentable {
+            public let rawValue: String
+            public init(rawValue: String) { self.rawValue = rawValue }
+            public static let introductory = OfferType(rawValue: "introductory")
+            public static let promotional = OfferType(rawValue: "promotional")
+            public static let winBack = OfferType(rawValue: "winBack")
+            public static let code = OfferType(rawValue: "code")
+            public var localizedDescription: String { rawValue }
+        }
+
+        public struct PaymentMode: Hashable, Sendable, RawRepresentable {
+            public let rawValue: String
+            public init(rawValue: String) { self.rawValue = rawValue }
+            public static let freeTrial = PaymentMode(rawValue: "FREE_TRIAL")
+            public static let payAsYouGo = PaymentMode(rawValue: "PAY_AS_YOU_GO")
+            public static let payUpFront = PaymentMode(rawValue: "PAY_UP_FRONT")
+            public var localizedDescription: String { rawValue }
+        }
+
+        public let id: String?
+        public let type: OfferType
+        public let price: Decimal
+        public let displayPrice: String
+        public let period: SubscriptionPeriod
+        public let periodCount: Int
+        public let paymentMode: PaymentMode
+    }
+
+    public struct SubscriptionInfo: Hashable, Sendable {
+        public let subscriptionGroupID: String
+        public let subscriptionPeriod: SubscriptionPeriod
+        public let introductoryOffer: SubscriptionOffer?
+        public let promotionalOffers: [SubscriptionOffer]
+        public let winBackOffers: [SubscriptionOffer]
+        public let subscriptionGroupLevel: Int
+        /// The subscription's level in its group (1 is the highest).
+        public var groupLevel: Int { subscriptionGroupLevel }
+        public let groupDisplayName: String
+        public let pricingTerms: [PricingTerms]
+
+        /// Not eligible: there is no App Store account to check.
+        public var isEligibleForIntroOffer: Bool { get async { false } }
+        public static func isEligibleForIntroOffer(for groupID: String) async -> Bool { false }
+
+        /// No statuses: nothing is subscribed to in the browser.
+        public var status: [Status] { get async throws { [] } }
+        public static func status(for groupID: String) async throws -> [Status] { [] }
+
+        /// A subscription group's status. There are none in the browser.
+        public struct Status: Hashable, Sendable {
+            public let state: RenewalState
+            public let transaction: VerificationResult<Transaction>
+            public let renewalInfo: VerificationResult<RenewalInfo>
+
+            /// Status changes: none in the browser; the sequence ends at once.
+            public static var updates: Statuses { Statuses() }
+            public static var all: AsyncStream<(groupID: String, statuses: [Status])> { AsyncStream { $0.finish() } }
+
+            public struct Statuses: AsyncSequence, Sendable {
+                public typealias Element = Status
+                public struct AsyncIterator: AsyncIteratorProtocol {
+                    public mutating func next() async -> Status? { nil }
+                }
+                public func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
+            }
+
+            public static func == (lhs: Status, rhs: Status) -> Bool {
+                lhs.state == rhs.state && lhs.transaction.unsafePayloadValue == rhs.transaction.unsafePayloadValue
+            }
+            public func hash(into hasher: inout Hasher) {
+                hasher.combine(state)
+                hasher.combine(transaction.unsafePayloadValue)
+            }
+        }
+
+        public struct RenewalState: Hashable, Sendable, RawRepresentable {
+            public let rawValue: Int
+            public init(rawValue: Int) { self.rawValue = rawValue }
+            public static let subscribed = RenewalState(rawValue: 1)
+            public static let expired = RenewalState(rawValue: 2)
+            public static let inBillingRetryPeriod = RenewalState(rawValue: 3)
+            public static let inGracePeriod = RenewalState(rawValue: 4)
+            public static let revoked = RenewalState(rawValue: 5)
+            public var localizedDescription: String { "\(rawValue)" }
+        }
+
+        /// What happens at the next renewal.
+        public struct RenewalInfo: Hashable, Sendable {
+            public struct ExpirationReason: Hashable, Sendable, RawRepresentable {
+                public let rawValue: Int
+                public init(rawValue: Int) { self.rawValue = rawValue }
+                public static let autoRenewDisabled = ExpirationReason(rawValue: 1)
+                public static let billingError = ExpirationReason(rawValue: 2)
+                public static let didNotConsentToPriceIncrease = ExpirationReason(rawValue: 3)
+                public static let productUnavailable = ExpirationReason(rawValue: 4)
+                public static let unknown = ExpirationReason(rawValue: 5)
+            }
+
+            public struct PriceIncreaseStatus: Hashable, Sendable {
+                public static let noIncreasePending = PriceIncreaseStatus()
+            }
+
+            public let originalTransactionID: UInt64
+            public let currentProductID: String
+            public let willAutoRenew: Bool
+            public let autoRenewPreference: String?
+            public let expirationReason: ExpirationReason?
+            public let isInBillingRetry: Bool
+            public let gracePeriodExpirationDate: Date?
+            public let renewalDate: Date?
+            public let recentSubscriptionStartDate: Date
+            public let offerID: String?
+            public let offerType: Transaction.OfferType?
+            public let offer: Transaction.Offer?
+            public let renewalPrice: Decimal?
+            public let currency: Locale.Currency?
+            public let environment: AppStore.Environment
+            public let eligibleWinBackOfferIDs: [String]
+            public let appAccountToken: UUID?
+            public let signedDate: Date
+            public let jsonRepresentation: Data
+            public var currencyCode: String? { currency?.identifier }
+        }
+
+        /// A billing plan (iOS 26.4): paying for a subscription monthly or up front.
+        public struct BillingPlanType: Hashable, Sendable, RawRepresentable {
+            public let rawValue: String
+            public init(rawValue: String) { self.rawValue = rawValue }
+            public static let monthly = BillingPlanType(rawValue: "monthly")
+            public static let upFront = BillingPlanType(rawValue: "upFront")
+        }
+
+        /// The price and offers of one billing plan (iOS 26.4).
+        public struct PricingTerms: Hashable, Sendable {
+            /// How long the plan commits to.
+            public struct CommitmentInfo: Hashable, Sendable {
+                public let period: SubscriptionPeriod
+            }
+
+            public let billingPlanType: BillingPlanType
+            public let billingPrice: Decimal
+            public let billingDisplayPrice: String
+            public let commitmentInfo: CommitmentInfo
+            public let subscriptionOffers: [SubscriptionOffer]
+        }
+    }
+}

package/Sources/StoreKit/RequestReview.swift

@@ -0,0 +1,28 @@
+// StoreKit, as far as a web app can use it: asking for an App Store review.
+// A web app has no store page to review, so the request does nothing (iOS
+// itself may also decline to show the prompt).
+
+import SwiftUI
+
+/// `@Environment(\.requestReview)`: call it to ask for a review. A no-op in
+/// the browser.
+public struct RequestReviewAction: Sendable {
+    public init() {}
+
+    @MainActor public func callAsFunction() {}
+}
+
+private struct RequestReviewKey: EnvironmentKey {
+    static let defaultValue = RequestReviewAction()
+}
+
+extension EnvironmentValues {
+    public var requestReview: RequestReviewAction {
+        self[RequestReviewKey.self]
+    }
+}
+
+/// The pre-iOS 16 way to ask for a review. A no-op in the browser.
+public enum SKStoreReviewController {
+    @MainActor public static func requestReview() {}
+}