@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/Combine/Scheduler.swift

@@ -0,0 +1,89 @@
+//
+//  Scheduler.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 11.06.2019.
+//
+
+/// A protocol that provides a scheduler with an expression for relative time.
+public protocol SchedulerTimeIntervalConvertible {
+
+    /// Converts the specified number of seconds into an instance of this scheduler time
+    /// type.
+    static func seconds(_ s: Int) -> Self
+
+    /// Converts the specified number of seconds, as a floating-point value, into
+    /// an instance of this scheduler time type.
+    static func seconds(_ s: Double) -> Self
+
+    /// Converts the specified number of milliseconds into an instance of this scheduler
+    /// time type.
+    static func milliseconds(_ ms: Int) -> Self
+
+    /// Converts the specified number of microseconds into an instance of this scheduler
+    /// time type.
+    static func microseconds(_ us: Int) -> Self
+
+    /// Converts the specified number of nanoseconds into an instance of this scheduler
+    /// time type.
+    static func nanoseconds(_ ns: Int) -> Self
+}
+
+extension Scheduler {
+
+    /// Performs the action at some time after the specified date, using the scheduler’s
+    /// minimum tolerance.
+    ///
+    /// The immediate scheduler ignores `date` and performs the action immediately.
+    @inlinable
+    public func schedule(after date: SchedulerTimeType,
+                         _ action: @escaping () -> Void) {
+        schedule(after: date, tolerance: minimumTolerance, action)
+    }
+
+    /// Performs the action at the next possible opportunity, without options.
+    @inlinable
+    public func schedule(_ action: @escaping () -> Void) {
+        schedule(options: nil, action)
+    }
+
+    /// Performs the action at some time after the specified date.
+    ///
+    /// The immediate scheduler ignores `date` and performs the action immediately.
+    @inlinable
+    public func schedule(after date: SchedulerTimeType,
+                         tolerance: SchedulerTimeType.Stride,
+                         _ action: @escaping () -> Void) {
+        schedule(after: date, tolerance: tolerance, options: nil, action)
+    }
+
+    /// Performs the action at some time after the specified date, at the specified
+    /// frequency, taking into account tolerance if possible.
+    ///
+    /// The immediate scheduler ignores `date` and performs the action immediately.
+    @inlinable
+    public func schedule(after date: SchedulerTimeType,
+                         interval: SchedulerTimeType.Stride,
+                         tolerance: SchedulerTimeType.Stride,
+                         _ action: @escaping () -> Void) -> Cancellable {
+        return schedule(after: date,
+                        interval: interval,
+                        tolerance: tolerance,
+                        options: nil,
+                        action)
+    }
+
+    /// Performs the action at some time after the specified date, at the specified
+    /// frequency, using minimum tolerance possible for this Scheduler.
+    ///
+    /// The immediate scheduler ignores `date` and performs the action immediately.
+    @inlinable
+    public func schedule(after date: SchedulerTimeType,
+                         interval: SchedulerTimeType.Stride,
+                         _ action: @escaping () -> Void) -> Cancellable {
+        return schedule(after: date,
+                        interval: interval,
+                        tolerance: minimumTolerance,
+                        action)
+    }
+}

package/Sources/Combine/Schedulers.swift

@@ -0,0 +1,211 @@
+// FoundationBridge's `DispatchQueue` and `RunLoop` as Combine schedulers, as
+// Apple's Combine makes Dispatch's and Foundation's, so that
+// `.debounce(for: .milliseconds(500), scheduler: DispatchQueue.main)` and
+// `.receive(on: RunLoop.main)` work. Every queue is the main queue
+// (FoundationBridge/Dispatch.swift): an action runs on the main actor's next
+// turn, a later one after a sleep on the executor's clock (so headless runs
+// keep their virtual time), and a repeating one until cancelled. Tolerances
+// and options are accepted.
+//
+// `View.onReceive` takes Combine's publishers too (the SwiftUI shim's own
+// takes its `_Publisher`s): values are delivered on the main actor while the
+// view is on screen.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+// MARK: - DispatchQueue
+
+extension FoundationBridge.DispatchQueue: Scheduler {
+    /// An instant: a `DispatchTime`.
+    public struct SchedulerTimeType: Strideable, Codable, Hashable, Sendable {
+        public var dispatchTime: FoundationBridge.DispatchTime
+
+        public init(_ time: FoundationBridge.DispatchTime) { dispatchTime = time }
+
+        public func distance(to other: SchedulerTimeType) -> Stride {
+            Stride(Int(Int64(bitPattern: other.dispatchTime.uptimeNanoseconds &- dispatchTime.uptimeNanoseconds)))
+        }
+
+        public func advanced(by n: Stride) -> SchedulerTimeType {
+            SchedulerTimeType(dispatchTime._adding(nanoseconds: Double(n.magnitude)))
+        }
+
+        public init(from decoder: any Decoder) throws {
+            self.init(FoundationBridge.DispatchTime(uptimeNanoseconds: try UInt64(from: decoder)))
+        }
+
+        public func encode(to encoder: any Encoder) throws {
+            try dispatchTime.uptimeNanoseconds.encode(to: encoder)
+        }
+
+        /// A span of time, in nanoseconds.
+        public struct Stride: SchedulerTimeIntervalConvertible, Comparable, SignedNumeric, ExpressibleByFloatLiteral,
+                              Hashable, Codable, Sendable {
+            public var magnitude: Int
+
+            public init(_ nanoseconds: Int) { magnitude = nanoseconds }
+            public init(integerLiteral value: Int) { magnitude = value * 1_000_000_000 }
+            public init(floatLiteral value: Double) { magnitude = Int(value * 1_000_000_000) }
+            public init?<T: BinaryInteger>(exactly source: T) {
+                guard let value = Int(exactly: source) else { return nil }
+                magnitude = value
+            }
+
+            public static func seconds(_ s: Int) -> Stride { Stride(s * 1_000_000_000) }
+            public static func seconds(_ s: Double) -> Stride { Stride(Int(s * 1_000_000_000)) }
+            public static func milliseconds(_ ms: Int) -> Stride { Stride(ms * 1_000_000) }
+            public static func microseconds(_ us: Int) -> Stride { Stride(us * 1_000) }
+            public static func nanoseconds(_ ns: Int) -> Stride { Stride(ns) }
+
+            public static func < (lhs: Stride, rhs: Stride) -> Bool { lhs.magnitude < rhs.magnitude }
+            public static func + (lhs: Stride, rhs: Stride) -> Stride { Stride(lhs.magnitude + rhs.magnitude) }
+            public static func - (lhs: Stride, rhs: Stride) -> Stride { Stride(lhs.magnitude - rhs.magnitude) }
+            public static func * (lhs: Stride, rhs: Stride) -> Stride { Stride(lhs.magnitude * rhs.magnitude) }
+            public static func += (lhs: inout Stride, rhs: Stride) { lhs = lhs + rhs }
+            public static func -= (lhs: inout Stride, rhs: Stride) { lhs = lhs - rhs }
+            public static func *= (lhs: inout Stride, rhs: Stride) { lhs = lhs * rhs }
+        }
+    }
+
+    public struct SchedulerOptions: Sendable {}
+
+    public var now: SchedulerTimeType { SchedulerTimeType(.now()) }
+    public var minimumTolerance: SchedulerTimeType.Stride { SchedulerTimeType.Stride(0) }
+
+    public func schedule(options: SchedulerOptions?, _ action: @escaping () -> Void) {
+        async(execute: action)
+    }
+
+    public func schedule(after date: SchedulerTimeType, tolerance: SchedulerTimeType.Stride,
+                         options: SchedulerOptions?, _ action: @escaping () -> Void) {
+        asyncAfter(deadline: date.dispatchTime, execute: action)
+    }
+
+    public func schedule(after date: SchedulerTimeType, interval: SchedulerTimeType.Stride,
+                         tolerance: SchedulerTimeType.Stride, options: SchedulerOptions?,
+                         _ action: @escaping () -> Void) -> any Cancellable {
+        _RepeatingSchedule.start(delay: max(0, Double(now.distance(to: date).magnitude)) / 1e9,
+                                 interval: Double(interval.magnitude) / 1e9, action: action)
+    }
+}
+
+// MARK: - RunLoop
+
+extension FoundationBridge.RunLoop: Scheduler {
+    /// An instant: a `Date`.
+    public struct SchedulerTimeType: Strideable, Codable, Hashable, Sendable {
+        public var date: Date
+
+        public init(_ date: Date) { self.date = date }
+
+        public func distance(to other: SchedulerTimeType) -> Stride {
+            Stride(other.date.timeIntervalSince(date))
+        }
+
+        public func advanced(by n: Stride) -> SchedulerTimeType {
+            SchedulerTimeType(date.addingTimeInterval(n.magnitude))
+        }
+
+        /// A span of time, in seconds.
+        public struct Stride: SchedulerTimeIntervalConvertible, Comparable, SignedNumeric, ExpressibleByFloatLiteral,
+                              Hashable, Codable, Sendable {
+            public var magnitude: TimeInterval
+
+            public init(_ timeInterval: TimeInterval) { magnitude = timeInterval }
+            public init(integerLiteral value: Int) { magnitude = TimeInterval(value) }
+            public init(floatLiteral value: Double) { magnitude = value }
+            public init?<T: BinaryInteger>(exactly source: T) {
+                guard let value = TimeInterval(exactly: source) else { return nil }
+                magnitude = value
+            }
+
+            public static func seconds(_ s: Int) -> Stride { Stride(TimeInterval(s)) }
+            public static func seconds(_ s: Double) -> Stride { Stride(s) }
+            public static func milliseconds(_ ms: Int) -> Stride { Stride(TimeInterval(ms) / 1e3) }
+            public static func microseconds(_ us: Int) -> Stride { Stride(TimeInterval(us) / 1e6) }
+            public static func nanoseconds(_ ns: Int) -> Stride { Stride(TimeInterval(ns) / 1e9) }
+
+            public static func < (lhs: Stride, rhs: Stride) -> Bool { lhs.magnitude < rhs.magnitude }
+            public static func + (lhs: Stride, rhs: Stride) -> Stride { Stride(lhs.magnitude + rhs.magnitude) }
+            public static func - (lhs: Stride, rhs: Stride) -> Stride { Stride(lhs.magnitude - rhs.magnitude) }
+            public static func * (lhs: Stride, rhs: Stride) -> Stride { Stride(lhs.magnitude * rhs.magnitude) }
+            public static func += (lhs: inout Stride, rhs: Stride) { lhs = lhs + rhs }
+            public static func -= (lhs: inout Stride, rhs: Stride) { lhs = lhs - rhs }
+            public static func *= (lhs: inout Stride, rhs: Stride) { lhs = lhs * rhs }
+        }
+    }
+
+    public struct SchedulerOptions: Sendable {}
+
+    public var now: SchedulerTimeType { SchedulerTimeType(Date()) }
+    public var minimumTolerance: SchedulerTimeType.Stride { SchedulerTimeType.Stride(0) }
+
+    public func schedule(options: SchedulerOptions?, _ action: @escaping () -> Void) {
+        FoundationBridge.DispatchQueue.main.async(execute: action)
+    }
+
+    public func schedule(after date: SchedulerTimeType, tolerance: SchedulerTimeType.Stride,
+                         options: SchedulerOptions?, _ action: @escaping () -> Void) {
+        FoundationBridge.DispatchQueue.main.asyncAfter(deadline: .now() + max(0, date.date.timeIntervalSinceNow),
+                                                       execute: action)
+    }
+
+    public func schedule(after date: SchedulerTimeType, interval: SchedulerTimeType.Stride,
+                         tolerance: SchedulerTimeType.Stride, options: SchedulerOptions?,
+                         _ action: @escaping () -> Void) -> any Cancellable {
+        _RepeatingSchedule.start(delay: max(0, date.date.timeIntervalSinceNow), interval: interval.magnitude, action: action)
+    }
+}
+
+/// A repeating action on the executor's clock, until cancelled.
+final class _RepeatingSchedule: Cancellable, @unchecked Sendable {
+    private var task: Task<Void, Never>?
+
+    static func start(delay: Double, interval: Double, action: @escaping () -> Void) -> _RepeatingSchedule {
+        let schedule = _RepeatingSchedule()
+        nonisolated(unsafe) let action = action
+        schedule.task = Task { @MainActor in
+            try? await Task.sleep(for: .seconds(delay))
+            while !Task.isCancelled {
+                action()
+                try? await Task.sleep(for: .seconds(max(interval, 0.001)))
+            }
+        }
+        return schedule
+    }
+
+    func cancel() {
+        task?.cancel()
+        task = nil
+    }
+}
+
+// MARK: - onReceive
+
+/// A Combine publisher as the shim's `_Publisher`, for `onReceive`.
+struct _CombinePublisher<Upstream: Publisher>: _Publisher where Upstream.Failure == Never {
+    let upstream: Upstream
+
+    @MainActor func _subscribe(_ receive: @escaping @MainActor (Upstream.Output) -> Void) -> any _Cancellable {
+        let cancellable = upstream.sink { value in
+            MainActor.assumeIsolated { receive(value) }
+        }
+        return _CombineCancellable(cancellable: cancellable)
+    }
+}
+
+struct _CombineCancellable: _Cancellable, @unchecked Sendable {
+    let cancellable: AnyCancellable
+    func cancel() { cancellable.cancel() }
+}
+
+extension View {
+    /// Runs `action` with each value the Combine publisher sends while the view is on screen.
+    @_disfavoredOverload
+    public func onReceive<P: Publisher>(_ publisher: P, perform action: @escaping (P.Output) -> Void) -> some View
+    where P.Failure == Never {
+        onReceive(_CombinePublisher(upstream: publisher), perform: action)
+    }
+}

package/Sources/Combine/Subject+Void.swift

@@ -0,0 +1,17 @@
+//
+//  Subject+Void.swift
+//  OpenCombine
+//
+//  Created by Sergej Jaskiewicz on 10.06.2019.
+//
+
+extension Subject where Output == Void {
+
+    /// Sends a void value to the subscriber.
+    ///
+    /// Use `Void` inputs and outputs when you want to signal that an event has occurred,
+    /// but don’t need to send the event itself.
+    public func send() {
+        send(())
+    }
+}

package/Sources/Combine/Subscriber+Void.swift

@@ -0,0 +1,20 @@
+//
+//  Subscriber+Void.swift
+//  OpenCombine
+//
+//  Created by Sergej Jaskiewicz on 10.06.2019.
+//
+
+extension Subscriber where Input == Void {
+
+    /// Tells the subscriber that a publisher of void elements is ready to receive further
+    /// requests.
+    ///
+    /// Use `Void` inputs and outputs when you want to signal that an event has occurred,
+    /// but don’t need to send the event itself.
+    /// - Returns: A `Subscribers.Demand` instance indicating how many more elements
+    /// the subscriber expects to receive.
+    public func receive() -> Subscribers.Demand {
+        return receive(())
+    }
+}

package/Sources/Combine/Subscribers/Subscribers.Assign.swift

@@ -0,0 +1,175 @@
+//
+//  Subscribers.Assign.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 15.06.2019.
+//
+
+extension Subscribers {
+
+    /// A simple subscriber that assigns received elements to a property indicated by
+    /// a key path.
+    public final class Assign<Root, Input>: Subscriber,
+                                            Cancellable,
+                                            CustomStringConvertible,
+                                            CustomReflectable,
+                                            CustomPlaygroundDisplayConvertible
+    {
+        public typealias Failure = Never
+
+        private let lock = UnfairLock.allocate()
+
+        /// The object that contains the property to assign.
+        ///
+        /// The subscriber holds a strong reference to this object until the upstream
+        /// publisher calls `Subscriber.receive(completion:)`, at which point
+        /// the subscriber sets this property to `nil`.
+        public private(set) var object: Root?
+
+        /// The key path that indicates the property to assign.
+        public let keyPath: ReferenceWritableKeyPath<Root, Input>
+
+        private var status = SubscriptionStatus.awaitingSubscription
+
+        /// A textual representation of this subscriber.
+        public var description: String { return "Assign \(Root.self)." }
+
+        /// A mirror that reflects the subscriber.
+        public var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("object", object as Any),
+                ("keyPath", keyPath),
+                ("status", status as Any)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        public var playgroundDescription: Any { return description }
+
+        /// Creates a subscriber to assign the value of a property indicated by
+        /// a key path.
+        ///
+        /// - Parameters:
+        ///   - object: The object that contains the property. The subscriber assigns
+        ///     the object’s property every time it receives a new value.
+        ///   - keyPath: A key path that indicates the property to assign. See
+        ///     [Key-Path Expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#ID563)
+        ///     in _The Swift Programming Language_ to learn how to use key paths to
+        ///     specify a property of an object.
+        public init(object: Root, keyPath: ReferenceWritableKeyPath<Root, Input>) {
+            self.object = object
+            self.keyPath = keyPath
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        public func receive(subscription: Subscription) {
+            lock.lock()
+            guard case .awaitingSubscription = status else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            status = .subscribed(subscription)
+            lock.unlock()
+            subscription.request(.unlimited)
+        }
+
+        public func receive(_ value: Input) -> Subscribers.Demand {
+            lock.lock()
+            guard case .subscribed = status, let object = self.object else {
+                lock.unlock()
+                return .none
+            }
+            lock.unlock()
+            object[keyPath: keyPath] = value
+            return .none
+        }
+
+        public func receive(completion: Subscribers.Completion<Never>) {
+            lock.lock()
+            guard case .subscribed = status else {
+                lock.unlock()
+                return
+            }
+            terminateAndConsumeLock()
+        }
+
+        public func cancel() {
+            lock.lock()
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            terminateAndConsumeLock()
+            subscription.cancel()
+        }
+
+        private func terminateAndConsumeLock() {
+#if DEBUG
+            lock.assertOwner()
+#endif
+            status = .terminal
+
+            // We MUST release the object AFTER unlocking the lock,
+            // since releasing it may trigger execution of arbitrary code,
+            // for example, if the object has a deinit.
+            // When the object deallocates, its deinit is called, and holding
+            // the lock at that moment can lead to deadlocks.
+
+            withExtendedLifetime(object) {
+                object = nil
+                lock.unlock()
+            }
+        }
+    }
+}
+
+extension Publisher where Failure == Never {
+
+    /// Assigns each element from a publisher to a property on an object.
+    ///
+    /// Use the `assign(to:on:)` subscriber when you want to set a given property each
+    /// time a publisher produces a value.
+    ///
+    /// In this example, the `assign(to:on:)` sets the value of the `anInt` property on
+    /// an instance of `MyClass`:
+    ///
+    ///     class MyClass {
+    ///         var anInt: Int = 0 {
+    ///             didSet {
+    ///                 print("anInt was set to: \(anInt)", terminator: "; ")
+    ///             }
+    ///         }
+    ///     }
+    ///
+    ///     var myObject = MyClass()
+    ///     let myRange = (0...2)
+    ///     cancellable = myRange.publisher
+    ///         .assign(to: \.anInt, on: myObject)
+    ///
+    ///     // Prints: "anInt was set to: 0; anInt was set to: 1; anInt was set to: 2"
+    ///
+    ///  > Important: The `Subscribers.Assign` instance created by this operator maintains
+    ///  a strong reference to `object`, and sets it to `nil` when the upstream publisher
+    ///  completes (either normally or with an error).
+    ///
+    /// - Parameters:
+    ///   - keyPath: A key path that indicates the property to assign. See
+    ///     [Key-Path Expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#ID563)
+    ///     in _The Swift Programming Language_ to learn how to use key paths to specify
+    ///     a property of an object.
+    ///   - object: The object that contains the property. The subscriber assigns
+    ///     the object’s property every time it receives a new value.
+    /// - Returns: An `AnyCancellable` instance. Call `cancel()` on this instance when you
+    ///   no longer want the publisher to automatically assign the property.
+    ///   Deinitializing this instance will also cancel automatic assignment.
+    public func assign<Root>(to keyPath: ReferenceWritableKeyPath<Root, Output>,
+                             on object: Root) -> AnyCancellable {
+        let subscriber = Subscribers.Assign(object: object, keyPath: keyPath)
+        subscribe(subscriber)
+        return AnyCancellable(subscriber)
+    }
+}

package/Sources/Combine/Subscribers/Subscribers.Completion.swift

@@ -0,0 +1,90 @@
+//
+//  Subscribers.Completion.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 11.06.2019.
+//
+
+#if canImport(_Concurrency) && compiler(>=5.5)
+import _Concurrency
+#endif
+
+extension Subscribers {
+
+    /// A signal that a publisher doesn’t produce additional elements, either due to
+    /// normal completion or an error.
+    public enum Completion<Failure: Error> {
+
+        /// The publisher finished normally.
+        case finished
+
+        /// The publisher stopped publishing due to the indicated error.
+        case failure(Failure)
+    }
+}
+
+extension Subscribers.Completion: Equatable where Failure: Equatable {}
+
+extension Subscribers.Completion: Hashable where Failure: Hashable {}
+
+#if canImport(_Concurrency) && compiler(>=5.5) || compiler(>=5.5.1)
+extension Subscribers.Completion: Sendable {}
+#endif
+
+extension Subscribers.Completion {
+    private enum CodingKeys: String, CodingKey {
+        case success = "success"
+        case error = "error"
+    }
+}
+
+extension Subscribers.Completion: Encodable where Failure: Encodable {
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .finished:
+            try container.encode(true, forKey: .success)
+        case .failure(let error):
+            try container.encode(false, forKey: .success)
+            try container.encode(error, forKey: .error)
+        }
+    }
+}
+
+extension Subscribers.Completion: Decodable where Failure: Decodable {
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let success = try container.decode(Bool.self, forKey: .success)
+        if success {
+            self = .finished
+        } else {
+            let error = try container.decode(Failure.self, forKey: .error)
+            self = .failure(error)
+        }
+    }
+}
+
+extension Subscribers.Completion {
+
+    /// Erases the `Failure` type to `Swift.Error`. This function exists
+    /// because in Swift user-defined generic types are always
+    /// [invariant](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)).
+    internal func eraseError() -> Subscribers.Completion<Error> {
+        switch self {
+        case .finished:
+            return .finished
+        case .failure(let error):
+            return .failure(error)
+        }
+    }
+
+    internal var failure: Failure? {
+        switch self {
+        case .finished:
+            return nil
+        case .failure(let failure):
+            return failure
+        }
+    }
+}