@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/AuthenticationServices/AuthenticationServices.swift

@@ -0,0 +1,257 @@
+// `import AuthenticationServices` for the browser: signing in through a web
+// page that redirects back to the app. On iOS, `ASWebAuthenticationSession`
+// (and SwiftUI's `WebAuthenticationSession` over it) shows the provider's
+// page in a Safari sheet and catches the redirect to the app's URL scheme
+// (`myapp://?code=…`). A web page can do neither, so:
+//
+// 1. The page opens the provider's page in a popup window (a `webAuth` host
+//    request). When the browser blocks the popup (it only allows one shortly
+//    after a tap), the page asks the viewer to continue, and opens it from
+//    that click.
+// 2. The provider redirects the window to the page's own callback page, not
+//    to `myapp://`: the shim swaps the app's scheme for that page in OAuth
+//    redirect parameters, in this authorize URL and in the app's URLSession
+//    requests alike (FoundationBridge's WebAuthRedirects.swift).
+// 3. The callback page hands its URL to the app's page, which answers the
+//    request with it and closes the window. The session rebuilds
+//    `myapp://?code=…` from it, and the app gets what it gets on iOS.
+//
+// Closing the window is the viewer cancelling:
+// `ASWebAuthenticationSessionError.canceledLogin`. A popup shares the
+// browser's cookies, so an ephemeral session is not ephemeral; a page cannot
+// add headers to a window's navigation, so `additionalHeaderFields` are not
+// sent; a callback to an `https` host (`Callback.https`) cannot be caught.
+// Passkeys and saved passwords compile but find no credential
+// (Authorization.swift); Sign in with Apple and the rest of the framework are
+// not here (docs/ops-protocol.md, "Signing in").
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+import UIKit
+
+public let ASWebAuthenticationSessionErrorDomain = "com.apple.AuthenticationServices.WebAuthenticationSession"
+
+/// Why a web authentication session ended without a callback, with Apple's codes.
+public struct ASWebAuthenticationSessionError: Error, Hashable, Sendable, CustomNSError {
+    public enum Code: Int, Sendable {
+        /// The viewer closed the sign-in window (or no page could ask them).
+        case canceledLogin = 1
+        case presentationContextNotProvided = 2
+        /// The page could not open the sign-in window.
+        case presentationContextInvalid = 3
+    }
+
+    public let code: Code
+    public init(_ code: Code) { self.code = code }
+
+    public static let canceledLogin = Code.canceledLogin
+    public static let presentationContextNotProvided = Code.presentationContextNotProvided
+    public static let presentationContextInvalid = Code.presentationContextInvalid
+
+    public static var errorDomain: String { ASWebAuthenticationSessionErrorDomain }
+    public var errorCode: Int { code.rawValue }
+    public var errorUserInfo: [String: Any] { [:] }
+}
+
+/// `catch ASWebAuthenticationSessionError.canceledLogin`, as with an imported error.
+public func ~= (code: ASWebAuthenticationSessionError.Code, error: any Error) -> Bool {
+    (error as? ASWebAuthenticationSessionError)?.code == code
+}
+
+/// What a session presents over on iOS; the page needs none.
+public typealias ASPresentationAnchor = UIWindow
+
+/// Supplies the window a session presents over. The browser opens its own
+/// window, so the anchor is never asked for.
+public protocol ASWebAuthenticationPresentationContextProviding: AnyObject {
+    @MainActor func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor
+}
+
+/// A sign-in through the provider's web page, in a popup window (see the top of this file).
+open class ASWebAuthenticationSession: NSObject {
+    public typealias CompletionHandler = (URL?, (any Error)?) -> Void
+
+    /// How the provider's redirect is recognized as the end of the sign-in.
+    public struct Callback: Sendable {
+        enum Kind: Sendable, Equatable { case scheme(String), https(host: String, path: String) }
+        let kind: Kind
+
+        /// A redirect to `scheme:`, which the page receives at its callback page.
+        public static func customScheme(_ customScheme: String) -> Callback { Callback(kind: .scheme(customScheme)) }
+        /// A redirect to an `https` URL on the app's own domain. Another site's
+        /// window cannot be read, so the browser never sees it arrive.
+        public static func https(host: String, path: String) -> Callback { Callback(kind: .https(host: host, path: path)) }
+
+        public func matchesURL(_ url: URL) -> Bool {
+            switch kind {
+            case .scheme(let scheme): url.scheme?.lowercased() == scheme.lowercased()
+            case .https(let host, let path): url.scheme?.lowercased() == "https" && url.host?.lowercased() == host.lowercased() && url.path == path
+            }
+        }
+
+        var scheme: String? { if case .scheme(let scheme) = kind { scheme } else { nil } }
+    }
+
+    let url: URL
+    let callback: Callback?
+    let completionHandler: CompletionHandler
+
+    /// Asked for an anchor on iOS; never consulted in the browser.
+    open weak var presentationContextProvider: (any ASWebAuthenticationPresentationContextProviding)?
+    /// Kept; a popup shares the browser's cookies whatever it says.
+    open var prefersEphemeralWebBrowserSession = false
+    /// Kept; a page cannot add headers to a window's navigation.
+    open var additionalHeaderFields: [String: String]?
+
+    private var started = false
+    private var finished = false
+
+    public init(url URL: URL, callbackURLScheme: String?, completionHandler: @escaping CompletionHandler) {
+        self.url = URL
+        self.callback = callbackURLScheme.map { Callback.customScheme($0) }
+        self.completionHandler = completionHandler
+    }
+
+    public init(url URL: URL, callback: Callback, completionHandler: @escaping CompletionHandler) {
+        self.url = URL
+        self.callback = callback
+        self.completionHandler = completionHandler
+    }
+
+    /// Whether `start()` would start: once per session.
+    open var canStart: Bool { !started }
+
+    /// Asks the page to open the sign-in window. The completion handler runs
+    /// on the main actor with the app's callback URL, or an error. False when
+    /// the session has started already or the URL is not a web page.
+    @MainActor @discardableResult
+    open func start() -> Bool {
+        guard !started, let scheme = url.scheme?.lowercased(), scheme == "http" || scheme == "https" else { return false }
+        started = true
+        let url = url, callback = callback, ephemeral = prefersEphemeralWebBrowserSession
+        Task { @MainActor in
+            do {
+                let result = try await _WebAuthPage.authenticate(url: url, callbackScheme: callback?.scheme, ephemeral: ephemeral)
+                finish(result, nil)
+            } catch {
+                finish(nil, error)
+            }
+        }
+        return true
+    }
+
+    /// Closes the sign-in window. The completion handler is not called.
+    @MainActor
+    open func cancel() {
+        guard started, !finished else { return }
+        finished = true
+        _WebAuthPage.cancel()
+    }
+
+    @MainActor private func finish(_ url: URL?, _ error: (any Error)?) {
+        guard !finished else { return }
+        finished = true
+        completionHandler(url, error)
+    }
+}
+
+// MARK: - SwiftUI
+
+/// SwiftUI's sign-in action (`@Environment(\.webAuthenticationSession)`):
+/// `authenticate` opens the provider's page in a popup and returns the
+/// app's callback URL (see the top of this file).
+@MainActor
+public struct WebAuthenticationSession {
+    /// The browser session the sign-in window uses; the browser's own either way.
+    public struct BrowserSession: Hashable, Sendable {
+        let ephemeral: Bool
+        public static let ephemeral = BrowserSession(ephemeral: true)
+        public static let shared = BrowserSession(ephemeral: false)
+    }
+
+    nonisolated init() {}
+
+    /// Signs in at `url`; returns the provider's redirect to `callbackURLScheme`.
+    /// Throws `ASWebAuthenticationSessionError` (`.canceledLogin` when the
+    /// viewer closes the window).
+    public func authenticate(using url: URL, callbackURLScheme: String, preferredBrowserSession: BrowserSession? = nil) async throws -> URL {
+        try await _WebAuthPage.authenticate(url: url, callbackScheme: callbackURLScheme, ephemeral: preferredBrowserSession?.ephemeral ?? false)
+    }
+
+    /// As above; the header fields are not sent (a page cannot add headers to a window's navigation).
+    public func authenticate(using url: URL, callbackURLScheme: String, preferredBrowserSession: BrowserSession? = nil,
+                             additionalHeaderFields: [String: String]) async throws -> URL {
+        try await authenticate(using: url, callbackURLScheme: callbackURLScheme, preferredBrowserSession: preferredBrowserSession)
+    }
+
+    public func authenticate(using url: URL, callback: ASWebAuthenticationSession.Callback, preferredBrowserSession: BrowserSession? = nil,
+                             additionalHeaderFields: [String: String]) async throws -> URL {
+        try await _WebAuthPage.authenticate(url: url, callbackScheme: callback.scheme, ephemeral: preferredBrowserSession?.ephemeral ?? false)
+    }
+}
+
+private struct WebAuthenticationSessionKey: EnvironmentKey {
+    static var defaultValue: WebAuthenticationSession { WebAuthenticationSession() }
+}
+
+extension EnvironmentValues {
+    /// The sign-in action: a popup window on the page.
+    public var webAuthenticationSession: WebAuthenticationSession {
+        get { self[WebAuthenticationSessionKey.self] }
+    }
+}
+
+// MARK: - The page
+
+/// The `webAuth` host request both APIs send (docs/ops-protocol.md, "Signing in").
+@MainActor
+enum _WebAuthPage {
+    /// Sends a request to the page; tests replace it with a fake page.
+    static var transport: @MainActor (_JSON) async throws -> _JSON = { params in
+        try await _Runtime.shared._hostRequest(kind: "webAuth", params: params)
+    }
+
+    /// Opens `url` (its app-scheme redirect swapped for the callback page) in
+    /// the page's sign-in window and returns the app's callback URL.
+    static func authenticate(url: URL, callbackScheme: String?, ephemeral: Bool) async throws -> URL {
+        guard let scheme = url.scheme?.lowercased(), scheme == "http" || scheme == "https" else {
+            throw ASWebAuthenticationSessionError(.presentationContextInvalid)
+        }
+        if let callbackScheme { _WebAuthRedirects.register(scheme: callbackScheme) }
+        var params: [String: _JSON] = [
+            "action": .string("start"),
+            "url": .string(_WebAuthRedirects.rewriting(url: url).absoluteString),
+            "callbackPage": .string(_WebAuthRedirects.callbackPage),
+        ]
+        if let callbackScheme { params["callbackScheme"] = .string(callbackScheme) }
+        if ephemeral { params["ephemeral"] = .bool(true) }
+        let value: _JSON
+        do {
+            value = try await withTaskCancellationHandler {
+                try await transport(.object(params))
+            } onCancel: {
+                Task { @MainActor in cancel() }
+            }
+        } catch let failure as _HostRequestError {
+            throw error(from: failure.message)
+        }
+        guard case .object(let fields) = value, case .string(let received)? = fields["url"],
+              let result = URL(string: _WebAuthRedirects.appURL(fromCallback: received) ?? received)
+        else { throw ASWebAuthenticationSessionError(.presentationContextInvalid) }
+        return result
+    }
+
+    /// Asks the page to close the sign-in window; the pending `authenticate` fails as cancelled.
+    static func cancel() {
+        Task { @MainActor in _ = try? await transport(.object(["action": .string("cancel")])) }
+    }
+
+    /// The page reports a closed window (or a dismissed prompt) as `cancelled: …`;
+    /// headless runs without a fixture as `headless: …`, which is the same to the app.
+    static func error(from message: String) -> ASWebAuthenticationSessionError {
+        let lowered = message.lowercased()
+        if lowered.hasPrefix("cancel") || lowered.hasPrefix("headless") { return ASWebAuthenticationSessionError(.canceledLogin) }
+        return ASWebAuthenticationSessionError(.presentationContextInvalid)
+    }
+}

package/Sources/AuthenticationServices/Authorization.swift

@@ -0,0 +1,251 @@
+// Passkeys and saved passwords (`ASAuthorizationController`, and SwiftUI's
+// `AuthorizationController` over it), so an app that offers them compiles
+// and runs. In a browser a passkey is WebAuthn, which only answers for the
+// page's own domain; an app's relying party (`example.com` in Apple's Food
+// Truck) is another site, so no request can succeed. Every request ends in
+// `ASAuthorizationError.notHandled`, as on a device with no credential to
+// offer: the app's own sign-up (a password form, say) is the way in
+// (docs/ops-protocol.md, "Signing in").
+
+import Foundation
+import SwiftUI
+
+public let ASAuthorizationErrorDomain = "com.apple.AuthenticationServices.AuthorizationError"
+
+/// Why an authorization failed, with Apple's codes.
+public struct ASAuthorizationError: Error, Hashable, Sendable, CustomNSError, LocalizedError {
+    public enum Code: Int, Sendable {
+        case unknown = 1000
+        case canceled = 1001
+        case invalidResponse = 1002
+        /// No credential provider handled the requests: always, in the browser.
+        case notHandled = 1003
+        case failed = 1004
+        case notInteractive = 1005
+        case matchedExcludedCredential = 1006
+    }
+
+    public let code: Code
+    public init(_ code: Code) { self.code = code }
+
+    public static let unknown = Code.unknown
+    public static let canceled = Code.canceled
+    public static let invalidResponse = Code.invalidResponse
+    public static let notHandled = Code.notHandled
+    public static let failed = Code.failed
+    public static let notInteractive = Code.notInteractive
+    public static let matchedExcludedCredential = Code.matchedExcludedCredential
+
+    public static var errorDomain: String { ASAuthorizationErrorDomain }
+    public var errorCode: Int { code.rawValue }
+    public var errorUserInfo: [String: Any] { [:] }
+    public var errorDescription: String? {
+        code == .notHandled ? "No passkey or saved password is available in the browser." : "The authorization failed (\(code.rawValue))."
+    }
+}
+
+/// `catch ASAuthorizationError.canceled`, as with an imported error.
+public func ~= (code: ASAuthorizationError.Code, error: any Error) -> Bool {
+    (error as? ASAuthorizationError)?.code == code
+}
+
+/// A request for a credential, made by a provider.
+open class ASAuthorizationRequest: NSObject, @unchecked Sendable {
+    public let provider: any ASAuthorizationProvider
+    init(provider: any ASAuthorizationProvider) { self.provider = provider }
+}
+
+public protocol ASAuthorizationProvider: NSObjectProtocol {}
+
+/// Requests for passkeys of a relying party.
+open class ASAuthorizationPlatformPublicKeyCredentialProvider: NSObject, ASAuthorizationProvider, @unchecked Sendable {
+    public let relyingPartyIdentifier: String
+    public init(relyingPartyIdentifier: String) { self.relyingPartyIdentifier = relyingPartyIdentifier }
+
+    open func createCredentialAssertionRequest(challenge: Data) -> ASAuthorizationPlatformPublicKeyCredentialAssertionRequest {
+        ASAuthorizationPlatformPublicKeyCredentialAssertionRequest(provider: self, challenge: challenge)
+    }
+
+    open func createCredentialRegistrationRequest(challenge: Data, name: String, userID: Data) -> ASAuthorizationPlatformPublicKeyCredentialRegistrationRequest {
+        ASAuthorizationPlatformPublicKeyCredentialRegistrationRequest(provider: self, challenge: challenge, name: name, userID: userID)
+    }
+}
+
+open class ASAuthorizationPlatformPublicKeyCredentialAssertionRequest: ASAuthorizationRequest, @unchecked Sendable {
+    public var challenge: Data
+    public var relyingPartyIdentifier: String
+    init(provider: ASAuthorizationPlatformPublicKeyCredentialProvider, challenge: Data) {
+        self.challenge = challenge
+        self.relyingPartyIdentifier = provider.relyingPartyIdentifier
+        super.init(provider: provider)
+    }
+}
+
+open class ASAuthorizationPlatformPublicKeyCredentialRegistrationRequest: ASAuthorizationRequest, @unchecked Sendable {
+    public var challenge: Data
+    public var relyingPartyIdentifier: String
+    public var name: String
+    public var userID: Data
+    init(provider: ASAuthorizationPlatformPublicKeyCredentialProvider, challenge: Data, name: String, userID: Data) {
+        self.challenge = challenge
+        self.relyingPartyIdentifier = provider.relyingPartyIdentifier
+        self.name = name
+        self.userID = userID
+        super.init(provider: provider)
+    }
+}
+
+/// Requests for a saved password.
+open class ASAuthorizationPasswordProvider: NSObject, ASAuthorizationProvider, @unchecked Sendable {
+    override public init() {}
+    open func createRequest() -> ASAuthorizationPasswordRequest { ASAuthorizationPasswordRequest(provider: self) }
+}
+
+open class ASAuthorizationPasswordRequest: ASAuthorizationRequest, @unchecked Sendable {}
+
+public protocol ASAuthorizationCredential: NSObjectProtocol, Sendable {}
+
+/// A saved password.
+open class ASPasswordCredential: NSObject, ASAuthorizationCredential, @unchecked Sendable {
+    public let user: String
+    public let password: String
+    public init(user: String, password: String) {
+        self.user = user
+        self.password = password
+    }
+}
+
+/// A passkey sign-in.
+open class ASAuthorizationPlatformPublicKeyCredentialAssertion: NSObject, ASAuthorizationCredential, @unchecked Sendable {
+    public let userID: Data
+    public let credentialID: Data
+    public let rawClientDataJSON: Data
+    public let rawAuthenticatorData: Data
+    public let signature: Data
+    init(userID: Data, credentialID: Data, rawClientDataJSON: Data, rawAuthenticatorData: Data, signature: Data) {
+        self.userID = userID
+        self.credentialID = credentialID
+        self.rawClientDataJSON = rawClientDataJSON
+        self.rawAuthenticatorData = rawAuthenticatorData
+        self.signature = signature
+    }
+}
+
+/// A new passkey.
+open class ASAuthorizationPlatformPublicKeyCredentialRegistration: NSObject, ASAuthorizationCredential, @unchecked Sendable {
+    public let credentialID: Data
+    public let rawClientDataJSON: Data
+    public let rawAttestationObject: Data?
+    init(credentialID: Data, rawClientDataJSON: Data, rawAttestationObject: Data?) {
+        self.credentialID = credentialID
+        self.rawClientDataJSON = rawClientDataJSON
+        self.rawAttestationObject = rawAttestationObject
+    }
+}
+
+/// A way of signing in the app handles itself (`ASAuthorizationController.customAuthorizationMethods`).
+public struct ASAuthorizationCustomMethod: RawRepresentable, Hashable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+    public init(_ rawValue: String) { self.rawValue = rawValue }
+    public static let videoSubscriberAccount = ASAuthorizationCustomMethod("ASAuthorizationCustomMethodVideoSubscriberAccount")
+    public static let restorePurchase = ASAuthorizationCustomMethod("ASAuthorizationCustomMethodRestorePurchase")
+    public static let other = ASAuthorizationCustomMethod("ASAuthorizationCustomMethodOther")
+}
+
+/// What an `AuthorizationController` request ended with.
+public enum ASAuthorizationResult: Sendable {
+    case password(ASPasswordCredential)
+    case passkeyAssertion(ASAuthorizationPlatformPublicKeyCredentialAssertion)
+    case passkeyRegistration(ASAuthorizationPlatformPublicKeyCredentialRegistration)
+    case customMethod(ASAuthorizationCustomMethod)
+}
+
+/// A finished authorization: the credential and the provider that gave it.
+open class ASAuthorization: NSObject, @unchecked Sendable {
+    public let provider: any ASAuthorizationProvider
+    public let credential: any ASAuthorizationCredential
+    init(provider: any ASAuthorizationProvider, credential: any ASAuthorizationCredential) {
+        self.provider = provider
+        self.credential = credential
+    }
+}
+
+public protocol ASAuthorizationControllerDelegate: NSObjectProtocol {
+    @MainActor func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization)
+    @MainActor func authorizationController(controller: ASAuthorizationController, didCompleteWithError error: any Error)
+}
+
+extension ASAuthorizationControllerDelegate {
+    public func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization) {}
+    public func authorizationController(controller: ASAuthorizationController, didCompleteWithError error: any Error) {}
+}
+
+public protocol ASAuthorizationControllerPresentationContextProviding: NSObjectProtocol {
+    @MainActor func presentationAnchor(for controller: ASAuthorizationController) -> ASPresentationAnchor
+}
+
+/// Runs authorization requests; in the browser each run fails with
+/// `.notHandled` (see the top of this file).
+@MainActor
+open class ASAuthorizationController: NSObject {
+    /// How requests are shown: `.preferImmediatelyAvailableCredentials`
+    /// fails at once when there is nothing to offer, as here.
+    public struct RequestOptions: OptionSet, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let preferImmediatelyAvailableCredentials = RequestOptions(rawValue: 1 << 0)
+    }
+
+    public let authorizationRequests: [ASAuthorizationRequest]
+    public weak var delegate: (any ASAuthorizationControllerDelegate)?
+    public weak var presentationContextProvider: (any ASAuthorizationControllerPresentationContextProviding)?
+    public var customAuthorizationMethods: [ASAuthorizationCustomMethod] = []
+
+    public init(authorizationRequests: [ASAuthorizationRequest]) {
+        self.authorizationRequests = authorizationRequests
+    }
+
+    open func performRequests() { finish() }
+    open func performRequests(options: RequestOptions) { finish() }
+    open func performAutoFillAssistedRequests() {}
+    open func cancel() {
+        delegate?.authorizationController(controller: self, didCompleteWithError: ASAuthorizationError(.canceled))
+    }
+
+    private func finish() {
+        // Asynchronously, as the system sheet would answer.
+        Task { @MainActor in
+            delegate?.authorizationController(controller: self, didCompleteWithError: ASAuthorizationError(.notHandled))
+        }
+    }
+}
+
+/// SwiftUI's async front for `ASAuthorizationController`
+/// (`@Environment(\.authorizationController)`).
+public struct AuthorizationController: Sendable {
+    public init() {}
+
+    @MainActor public func performRequests(_ requests: [ASAuthorizationRequest], options: ASAuthorizationController.RequestOptions = []) async throws -> ASAuthorizationResult {
+        throw ASAuthorizationError(.notHandled)
+    }
+
+    @MainActor public func performRequest(_ request: ASAuthorizationRequest, options: ASAuthorizationController.RequestOptions = []) async throws -> ASAuthorizationResult {
+        throw ASAuthorizationError(.notHandled)
+    }
+
+    @MainActor public func performAutoFillAssistedRequests(_ requests: [ASAuthorizationRequest]) async throws -> ASAuthorizationResult {
+        throw ASAuthorizationError(.notHandled)
+    }
+}
+
+private struct AuthorizationControllerKey: EnvironmentKey {
+    static let defaultValue = AuthorizationController()
+}
+
+extension EnvironmentValues {
+    public var authorizationController: AuthorizationController {
+        get { self[AuthorizationControllerKey.self] }
+        set { self[AuthorizationControllerKey.self] = newValue }
+    }
+}

package/Sources/Charts/Charts.swift

@@ -0,0 +1,61 @@
+// Swift Charts for SwiftBrowser. The marks, axes and `Chart` itself are
+// defined in the SwiftUI target (Sources/SwiftUI/Charts); this module
+// re-exports them and adds the pieces that need Foundation's `Date` and
+// `Calendar`. See docs/ops-protocol.md, "Phase 7".
+
+@_exported import SwiftUI
+
+import Foundation
+
+/// Dates plot as seconds since 1970; the chart treats them as UTC
+/// (`Calendar.current` is UTC in the browser).
+extension Date: Plottable {
+    public var _plottableValue: _PlottableValue { .date(timeIntervalSince1970) }
+
+    public init?(_plottableValue value: _PlottableValue) {
+        guard case .date(let seconds) = value else { return nil }
+        self.init(timeIntervalSince1970: seconds)
+    }
+}
+
+/// Calendar bins over a date range: `DateBins(unit: .hour, by: 3, range:)`.
+/// `thresholds` are the bin boundaries, from the range's start (aligned to
+/// `unit`) in steps of `by` units up to and including the first boundary at or
+/// after the range's end.
+public struct DateBins: Sendable {
+    public let unit: Calendar.Component
+    public let stride: Int
+    public let range: ClosedRange<Date>
+    public let thresholds: [Date]
+
+    public init(unit: Calendar.Component, by stride: Int = 1, range: ClosedRange<Date>,
+                calendar: Calendar = .current) {
+        self.unit = unit
+        self.stride = max(1, stride)
+        self.range = range
+        var thresholds: [Date] = []
+        var date = calendar.dateInterval(of: unit, for: range.lowerBound)?.start ?? range.lowerBound
+        while thresholds.count < 10_000 {
+            thresholds.append(date)
+            if date >= range.upperBound { break }
+            guard let next = calendar.date(byAdding: unit, value: self.stride, to: date), next > date else { break }
+            date = next
+        }
+        self.thresholds = thresholds
+    }
+
+    /// Bins over the dates' span.
+    public init(unit: Calendar.Component, by stride: Int = 1, dates: [Date], calendar: Calendar = .current) {
+        let lower = dates.min() ?? Date(timeIntervalSince1970: 0)
+        let upper = dates.max() ?? lower
+        self.init(unit: unit, by: stride, range: lower...upper, calendar: calendar)
+    }
+
+    /// The bin a date falls in (an index into `thresholds`), clamped to the bins.
+    public func index(for date: Date) -> Int {
+        let bins = max(thresholds.count - 1, 1)
+        var index = 0
+        for (i, threshold) in thresholds.enumerated() where date >= threshold { index = i }
+        return min(index, bins - 1)
+    }
+}

package/Sources/Combine/AnyCancellable.swift

@@ -0,0 +1,65 @@
+//
+//  AnyCancellable.swift
+//
+//
+//  Created by Sergej Jaskiewicz on 26.06.2019.
+//
+
+/// A type-erasing cancellable object that executes a provided closure when canceled.
+///
+/// Subscriber implementations can use this type to provide a “cancellation token” that
+/// makes it possible for a caller to cancel a publisher, but not to use the
+/// `Subscription` object to request items.
+///
+/// An `AnyCancellable` instance automatically calls `cancel()` when deinitialized.
+public final class AnyCancellable: Cancellable, Hashable {
+
+    private var _cancel: (() -> Void)?
+
+    /// Initializes the cancellable object with the given cancel-time closure.
+    ///
+    /// - Parameter cancel: A closure that the `cancel()` method executes.
+    public init(_ cancel: @escaping () -> Void) {
+        _cancel = cancel
+    }
+
+    public init<OtherCancellable: Cancellable>(_ canceller: OtherCancellable) {
+        _cancel = canceller.cancel
+    }
+
+    public func cancel() {
+        _cancel?()
+        _cancel = nil
+    }
+
+    public static func == (lhs: AnyCancellable, rhs: AnyCancellable) -> Bool {
+        return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(ObjectIdentifier(self))
+    }
+
+    deinit {
+        _cancel?()
+    }
+}
+
+extension AnyCancellable {
+
+    /// Stores this type-erasing cancellable instance in the specified collection.
+    ///
+    /// - Parameter collection: The collection in which to store this `AnyCancellable`.
+    public func store<Cancellables: RangeReplaceableCollection>(
+        in collection: inout Cancellables
+    ) where Cancellables.Element == AnyCancellable {
+        collection.append(self)
+    }
+
+    /// Stores this type-erasing cancellable instance in the specified collection.
+    ///
+    /// - Parameter collection: The collection in which to store this `AnyCancellable`.
+    public func store(in set: inout Set<AnyCancellable>) {
+        set.insert(self)
+    }
+}