@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/Combine/AnyPublisher.swift

@@ -0,0 +1,148 @@
+//
+//  AnyPublisher.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 10.06.2019.
+//
+
+extension Publisher {
+
+    /// Wraps this publisher with a type eraser.
+    ///
+    /// Use `eraseToAnyPublisher()` to expose an instance of `AnyPublisher`` to
+    /// the downstream subscriber, rather than this publisher’s actual type.
+    /// This form of _type erasure_ preserves abstraction across API boundaries, such as
+    /// different modules.
+    /// When you expose your publishers as the `AnyPublisher` type, you can change
+    /// the underlying implementation over time without affecting existing clients.
+    ///
+    /// The following example shows two types that each have a `publisher` property.
+    /// `TypeWithSubject` exposes this property as its actual type, `PassthroughSubject`,
+    /// while `TypeWithErasedSubject` uses `eraseToAnyPublisher()` to expose it as
+    /// an `AnyPublisher`. As seen in the output, a caller from another module can access
+    /// `TypeWithSubject.publisher` as its native type. This means you can’t change your
+    /// publisher to a different type without breaking the caller. By comparison,
+    /// `TypeWithErasedSubject.publisher` appears to callers as an `AnyPublisher`, so you
+    /// can change the underlying publisher type at will.
+    ///
+    ///     public class TypeWithSubject {
+    ///         public let publisher: some Publisher = PassthroughSubject<Int,Never>()
+    ///     }
+    ///     public class TypeWithErasedSubject {
+    ///         public let publisher: some Publisher = PassthroughSubject<Int,Never>()
+    ///             .eraseToAnyPublisher()
+    ///     }
+    ///
+    ///     // In another module:
+    ///     let nonErased = TypeWithSubject()
+    ///     if let subject = nonErased.publisher as? PassthroughSubject<Int,Never> {
+    ///         print("Successfully cast nonErased.publisher.")
+    ///     }
+    ///     let erased = TypeWithErasedSubject()
+    ///     if let subject = erased.publisher as? PassthroughSubject<Int,Never> {
+    ///         print("Successfully cast erased.publisher.")
+    ///     }
+    ///
+    ///     // Prints "Successfully cast nonErased.publisher."
+    ///
+    /// - Returns: An ``AnyPublisher`` wrapping this publisher.
+    @inlinable
+    public func eraseToAnyPublisher() -> AnyPublisher<Output, Failure> {
+        return .init(self)
+    }
+}
+
+/// A type-erasing publisher.
+///
+/// Use `AnyPublisher` to wrap a publisher whose type has details you don’t want to expose
+/// across API boundaries, such as different modules. Wrapping a `Subject` with
+/// `AnyPublisher` also prevents callers from accessing its `send(_:)` method. When you
+/// use type erasure this way, you can change the underlying publisher implementation over
+/// time without affecting existing clients.
+///
+/// You can use OpenCombine’s `eraseToAnyPublisher()` operator to wrap a publisher with
+/// `AnyPublisher`.
+public struct AnyPublisher<Output, Failure: Error>
+  : CustomStringConvertible,
+    CustomPlaygroundDisplayConvertible
+{
+    @usableFromInline
+    internal let box: PublisherBoxBase<Output, Failure>
+
+    /// Creates a type-erasing publisher to wrap the provided publisher.
+    ///
+    /// - Parameter publisher: A publisher to wrap with a type-eraser.
+    @inlinable
+    public init<PublisherType: Publisher>(_ publisher: PublisherType)
+        where Output == PublisherType.Output, Failure == PublisherType.Failure
+    {
+        // If this has already been boxed, avoid boxing again
+        if let erased = publisher as? AnyPublisher<Output, Failure> {
+            box = erased.box
+        } else {
+            box = PublisherBox(base: publisher)
+        }
+    }
+
+    public var description: String {
+        return "AnyPublisher"
+    }
+
+    public var playgroundDescription: Any {
+        return description
+    }
+}
+
+extension AnyPublisher: Publisher {
+
+    /// This function is called to attach the specified `Subscriber` to this `Publisher`
+    /// by `subscribe(_:)`
+    ///
+    /// - SeeAlso: `subscribe(_:)`
+    /// - Parameters:
+    ///     - subscriber: The subscriber to attach to this `Publisher`.
+    ///                   once attached it can begin to receive values.
+    @inlinable
+    public func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Output == Downstream.Input, Failure == Downstream.Failure
+    {
+        box.receive(subscriber: subscriber)
+    }
+}
+
+/// A type-erasing base class. Its concrete subclass is generic over the underlying
+/// publisher.
+@usableFromInline
+internal class PublisherBoxBase<Output, Failure: Error>: Publisher {
+
+    @inlinable
+    internal init() {}
+
+    @usableFromInline
+    internal func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Failure == Downstream.Failure, Output == Downstream.Input
+    {
+        abstractMethod()
+    }
+}
+
+@usableFromInline
+internal final class PublisherBox<PublisherType: Publisher>
+    : PublisherBoxBase<PublisherType.Output, PublisherType.Failure>
+{
+    @usableFromInline
+    internal let base: PublisherType
+
+    @inlinable
+    internal init(base: PublisherType) {
+        self.base = base
+        super.init()
+    }
+
+    @inlinable
+    override internal func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Failure == Downstream.Failure, Output == Downstream.Input
+    {
+        base.receive(subscriber: subscriber)
+    }
+}

package/Sources/Combine/AnySubscriber.swift

@@ -0,0 +1,230 @@
+//
+//  AnySubscriber.swift
+//  OpenCombine
+//
+//  Created by Sergej Jaskiewicz on 10.06.2019.
+//
+
+/// A type-erasing subscriber.
+///
+/// Use an `AnySubscriber` to wrap an existing subscriber whose details you don’t want to
+/// expose. You can also use `AnySubscriber` to create a custom subscriber by providing
+/// closures for the methods defined in `Subscriber`, rather than implementing
+/// `Subscriber` directly.
+public struct AnySubscriber<Input, Failure: Error>: Subscriber,
+                                                    CustomStringConvertible,
+                                                    CustomReflectable,
+                                                    CustomPlaygroundDisplayConvertible
+{
+    @usableFromInline
+    internal let box: AnySubscriberBase<Input, Failure>
+
+    @usableFromInline
+    internal let descriptionThunk: () -> String
+
+    @usableFromInline
+    internal let customMirrorThunk: () -> Mirror
+
+    @usableFromInline
+    internal let playgroundDescriptionThunk: () -> Any
+
+    public let combineIdentifier: CombineIdentifier
+
+    public var description: String { return descriptionThunk() }
+
+    public var customMirror: Mirror { return customMirrorThunk() }
+
+    /// A custom playground description for this instance.
+    public var playgroundDescription: Any { return playgroundDescriptionThunk() }
+
+    /// Creates a type-erasing subscriber to wrap an existing subscriber.
+    ///
+    /// - Parameter s: The subscriber to type-erase.
+    @inline(__always)
+    @inlinable
+    public init<Subscriber: Combine.Subscriber>(_ subscriber: Subscriber)
+        where Input == Subscriber.Input, Failure == Subscriber.Failure
+    {
+        if let erased = subscriber as? AnySubscriber<Input, Failure> {
+            self = erased
+            return
+        }
+
+        combineIdentifier = subscriber.combineIdentifier
+
+        box = AnySubscriberBox(subscriber)
+
+        if let description = subscriber as? CustomStringConvertible {
+            descriptionThunk = { description.description }
+        } else {
+            let fixedDescription = String(describing: type(of: subscriber))
+            descriptionThunk = { fixedDescription }
+        }
+
+        customMirrorThunk = {
+            (subscriber as? CustomReflectable)?.customMirror
+                ?? Mirror(subscriber, children: EmptyCollection())
+        }
+
+        if let playgroundDescription = subscriber as? CustomPlaygroundDisplayConvertible {
+            playgroundDescriptionThunk = { playgroundDescription.playgroundDescription }
+        } else if let description = subscriber as? CustomStringConvertible {
+            playgroundDescriptionThunk = { description.description }
+        } else {
+            let fixedDescription = String(describing: type(of: subscriber))
+            playgroundDescriptionThunk = { fixedDescription }
+        }
+    }
+
+    public init<Subject: Combine.Subject>(_ subject: Subject)
+        where Input == Subject.Output, Failure == Subject.Failure
+    {
+        self.init(SubjectSubscriber(subject))
+    }
+
+    /// Creates a type-erasing subscriber that executes the provided closures.
+    ///
+    /// - Parameters:
+    ///   - receiveSubscription: A closure to execute when the subscriber receives
+    ///     the initial subscription from the publisher.
+    ///   - receiveValue: A closure to execute when the subscriber receives a value from
+    ///     the publisher.
+    ///   - receiveCompletion: A closure to execute when the subscriber receives
+    ///     a completion callback from the publisher.
+    @inline(__always)
+    @inlinable
+    public init(receiveSubscription: ((Subscription) -> Void)? = nil,
+                receiveValue: ((Input) -> Subscribers.Demand)? = nil,
+                receiveCompletion: ((Subscribers.Completion<Failure>) -> Void)? = nil) {
+
+        box = ClosureBasedAnySubscriber(
+            receiveSubscription ?? { _ in },
+            receiveValue ?? { _ in .none },
+            receiveCompletion ?? { _ in }
+        )
+
+        combineIdentifier = CombineIdentifier()
+        descriptionThunk = { "Anonymous AnySubscriber" }
+        customMirrorThunk = { Mirror(reflecting: "Anonymous AnySubscriber") }
+        playgroundDescriptionThunk = { "Anonymous AnySubscriber" }
+    }
+
+    @inline(__always)
+    @inlinable
+    public func receive(subscription: Subscription) {
+        box.receive(subscription: subscription)
+    }
+
+    @inline(__always)
+    @inlinable
+    public func receive(_ value: Input) -> Subscribers.Demand {
+        return box.receive(value)
+    }
+
+    @inline(__always)
+    @inlinable
+    public func receive(completion: Subscribers.Completion<Failure>) {
+        box.receive(completion: completion)
+    }
+}
+
+/// A type-erasing base class. Its concrete subclass is generic over the underlying
+/// subscriber.
+@usableFromInline
+internal class AnySubscriberBase<Input, Failure: Error>: Subscriber {
+
+    @inline(__always)
+    @inlinable
+    internal init() {}
+
+    @inline(__always)
+    @inlinable
+    deinit {}
+
+    @usableFromInline
+    internal func receive(subscription: Subscription) {
+        abstractMethod()
+    }
+
+    @usableFromInline
+    internal func receive(_ input: Input) -> Subscribers.Demand {
+        abstractMethod()
+    }
+
+    @usableFromInline
+    internal func receive(completion: Subscribers.Completion<Failure>) {
+        abstractMethod()
+    }
+}
+
+@usableFromInline
+internal final class AnySubscriberBox<Base: Subscriber>
+    : AnySubscriberBase<Base.Input, Base.Failure>
+{
+    @usableFromInline
+    internal let base: Base
+
+    @inlinable
+    internal init(_ base: Base) {
+        self.base = base
+    }
+
+    @inlinable
+    deinit {}
+
+    @inlinable
+    override internal func receive(subscription: Subscription) {
+        base.receive(subscription: subscription)
+    }
+
+    @inlinable
+    override internal func receive(_ input: Base.Input) -> Subscribers.Demand {
+        return base.receive(input)
+    }
+
+    @inlinable
+    override internal func receive(completion: Subscribers.Completion<Base.Failure>) {
+        base.receive(completion: completion)
+    }
+}
+
+@usableFromInline
+internal final class ClosureBasedAnySubscriber<Input, Failure: Error>
+    : AnySubscriberBase<Input, Failure>
+{
+    @usableFromInline
+    internal let receiveSubscriptionThunk: (Subscription) -> Void
+
+    @usableFromInline
+    internal let receiveValueThunk: (Input) -> Subscribers.Demand
+
+    @usableFromInline
+    internal let receiveCompletionThunk: (Subscribers.Completion<Failure>) -> Void
+
+    @inlinable
+    internal init(_ rcvSubscription: @escaping (Subscription) -> Void,
+                  _ rcvValue: @escaping (Input) -> Subscribers.Demand,
+                  _ rcvCompletion: @escaping (Subscribers.Completion<Failure>) -> Void) {
+        receiveSubscriptionThunk = rcvSubscription
+        receiveValueThunk = rcvValue
+        receiveCompletionThunk = rcvCompletion
+    }
+
+    @inlinable
+    deinit {}
+
+    @inlinable
+    override internal func receive(subscription: Subscription) {
+        receiveSubscriptionThunk(subscription)
+    }
+
+    @inlinable
+    override internal func receive(_ input: Input) -> Subscribers.Demand {
+        return receiveValueThunk(input)
+    }
+
+    @inlinable
+    override internal func receive(completion: Subscribers.Completion<Failure>) {
+        receiveCompletionThunk(completion)
+    }
+}

package/Sources/Combine/Cancellable.swift

@@ -0,0 +1,35 @@
+//
+//  Cancellable.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 10.06.2019.
+//
+
+/// A protocol indicating that an activity or action supports cancellation.
+///
+/// Calling `cancel()` frees up any allocated resources. It also stops side effects such
+/// as timers, network access, or disk I/O.
+public protocol Cancellable {
+
+    /// Cancel the activity.
+    func cancel()
+}
+
+extension Cancellable {
+
+    /// Stores this cancellable instance in the specified collection.
+    ///
+    /// - Parameter collection: The collection in which to store this `Cancellable`.
+    public func store<Cancellables: RangeReplaceableCollection>(
+            in collection: inout Cancellables
+    ) where Cancellables.Element == AnyCancellable {
+        AnyCancellable(self).store(in: &collection)
+    }
+
+    /// Stores this cancellable instance in the specified set.
+    ///
+    /// - Parameter set: The set in which to store this `Cancellable`.
+    public func store(in set: inout Set<AnyCancellable>) {
+        AnyCancellable(self).store(in: &set)
+    }
+}

package/Sources/Combine/Codable.swift

@@ -0,0 +1,29 @@
+//
+//  Codable.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 11.06.2019.
+//
+
+/// A type that defines methods for decoding.
+public protocol TopLevelDecoder {
+
+    /// The type this decoder accepts.
+    associatedtype Input
+
+    /// Decodes an instance of the indicated type.
+    func decode<DecodablyType: Decodable>(_ type: DecodablyType.Type,
+                                          from: Input) throws -> DecodablyType
+}
+
+/// A type that defines methods for encoding.
+public protocol TopLevelEncoder {
+
+    /// The type this encoder produces.
+    associatedtype Output
+
+    /// Encodes an instance of the indicated type.
+    ///
+    /// - Parameter value: The instance to encode.
+    func encode<EncodableType: Encodable>(_ value: EncodableType) throws -> Output
+}

package/Sources/Combine/CombineIdentifier.swift

@@ -0,0 +1,45 @@
+//
+//  CombineIdentifier.swift
+//  OpenCombine
+//
+//  Created by Sergej Jaskiewicz on 10.06.2019.
+//
+
+#if canImport(COpenCombineHelpers)
+import COpenCombineHelpers
+#endif
+
+#if WASI
+private var __identifier: UInt64 = 0
+
+internal func __nextCombineIdentifier() -> UInt64 {
+    defer { __identifier += 1 }
+    return __identifier
+}
+#endif // WASI
+
+/// A unique identifier for identifying publisher streams.
+///
+/// To conform to `CustomCombineIdentifierConvertible` in a
+/// `Subscription` or `Subject` that you implement as a structure, create an instance of
+/// `CombineIdentifier` as follows:
+///
+///     let combineIdentifier = CombineIdentifier()
+public struct CombineIdentifier: Hashable, CustomStringConvertible {
+
+    private let rawValue: UInt64
+
+    /// Creates a unique Combine identifier.
+    public init() {
+        rawValue = __nextCombineIdentifier()
+    }
+
+    /// Creates a Combine identifier, using the bit pattern of the provided object.
+    public init(_ obj: AnyObject) {
+        rawValue = UInt64(UInt(bitPattern: ObjectIdentifier(obj)))
+    }
+
+    public var description: String {
+        return "0x\(String(rawValue, radix: 16))"
+    }
+}

package/Sources/Combine/Concurrency/ConcurrencyHelpers.swift

@@ -0,0 +1,24 @@
+//
+//  ConcurrencyHelpers.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 14.11.2022.
+//
+
+#if canImport(_Concurrency) && compiler(>=5.5)
+import _Concurrency
+#endif
+
+#if (canImport(_Concurrency) && compiler(>=5.5) || compiler(>=5.5.1)) && swift(<5.7)
+/// A polyfill for pre-5.7 Swift versions.
+@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+internal func withTaskCancellationHandler<T>( // swiftlint:disable:this generic_type_name
+    operation: () async throws -> T,
+    onCancel handler: @Sendable () -> Void
+) async rethrows -> T {
+    return try await withTaskCancellationHandler(
+        handler: handler,
+        operation: operation
+    )
+}
+#endif

package/Sources/Combine/Concurrency/Future+Concurrency.swift

@@ -0,0 +1,136 @@
+//
+//  Future+Concurrency.swift
+//
+//
+//  Created by Sergej Jaskiewicz on 28.08.2021.
+//
+
+#if canImport(_Concurrency) && compiler(>=5.5)
+import _Concurrency
+#endif
+
+#if canImport(_Concurrency) && compiler(>=5.5) || compiler(>=5.5.1)
+extension Future where Failure == Never {
+
+    /// The published value of the future, delivered asynchronously.
+    ///
+    /// This property subscribes to the `Future` and delivers the value asynchronously
+    /// when the `Future` publishes it. Use this property when you want to use
+    /// the `async`-`await` syntax with a `Future`.
+    @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+    public var value: Output {
+        get async {
+            await ContinuationSubscriber.withUnsafeSubscription(self)
+        }
+    }
+}
+
+extension Future {
+
+    /// The published value of the future or an error, delivered asynchronously.
+    ///
+    /// This property subscribes to the `Future` and delivers the value asynchronously
+    /// when the `Future` publishes it. If the `Future` terminates with an error,
+    /// the awaiting caller receives the error instead. Use this property when you want
+    /// to the `async`-`await` syntax with a `Future` whose `Failure` type is not `Never`.
+    @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+    public var value: Output {
+        get async throws {
+            try await ContinuationSubscriber.withUnsafeThrowingSubscription(self)
+        }
+    }
+}
+
+@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+private final class ContinuationSubscriber<Input,
+                                           UpstreamFailure: Error,
+                                           ErrorOrNever: Error>
+    : Subscriber
+{
+    typealias Failure = UpstreamFailure
+
+    private var continuation: UnsafeContinuation<Input, ErrorOrNever>?
+    private var subscription: Subscription?
+    private let lock = UnfairLock.allocate()
+
+    private init(_ continuation: UnsafeContinuation<Input, ErrorOrNever>) {
+        self.continuation = continuation
+    }
+
+    deinit {
+        lock.deallocate()
+    }
+
+    func receive(subscription: Subscription) {
+        lock.lock()
+        guard self.subscription == nil else {
+            assertionFailure("Unexpected state: received subscription twice")
+            lock.unlock()
+            subscription.cancel()
+            return
+        }
+        self.subscription = subscription
+        lock.unlock()
+        subscription.request(.max(1))
+    }
+
+    func receive(_ input: Input) -> Subscribers.Demand {
+        lock.lock()
+        if let continuation = self.continuation.take() {
+            lock.unlock()
+            continuation.resume(returning: input)
+        } else {
+            assertionFailure("Unexpected state: already completed")
+            lock.unlock()
+        }
+        return .none
+    }
+
+    func receive(completion: Subscribers.Completion<Failure>) {
+        lock.lock()
+        subscription = nil
+        lock.unlock()
+        completion.failure.map(handleFailure)
+    }
+
+    private func handleFailure(_ error: Failure) {
+        lock.lock()
+        if let continuation = self.continuation.take() {
+            lock.unlock()
+            continuation.resume(throwing: error as! ErrorOrNever)
+        } else {
+            assertionFailure("Unexpected state: already completed")
+            lock.unlock()
+        }
+    }
+}
+
+@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+extension ContinuationSubscriber where ErrorOrNever == Error {
+    fileprivate static func withUnsafeThrowingSubscription<Upstream: Publisher>(
+        _ upstream: Upstream
+    ) async throws -> Input
+        where Upstream.Output == Input,
+              Upstream.Failure == UpstreamFailure
+    {
+        try await withUnsafeThrowingContinuation { continuation in
+            upstream.subscribe(ContinuationSubscriber(continuation))
+        }
+    }
+}
+
+@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+extension ContinuationSubscriber where UpstreamFailure == Never, ErrorOrNever == Never {
+    fileprivate static func withUnsafeSubscription<Upstream: Publisher>(
+        _ upstream: Upstream
+    ) async -> Input
+        where Upstream.Output == Input,
+              Upstream.Failure == Never
+    {
+        await withUnsafeContinuation { continuation in
+            upstream.subscribe(ContinuationSubscriber(continuation))
+        }
+    }
+}
+
+#endif