@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/Combine/ImmediateScheduler.swift

@@ -0,0 +1,178 @@
+//
+//  ImmediateScheduler.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 11.06.2019.
+//
+
+/// A scheduler for performing synchronous actions.
+///
+/// You can only use this scheduler for immediate actions. If you attempt to schedule
+/// actions after a specific date, this scheduler ignores the date and performs them
+/// immediately.
+public struct ImmediateScheduler: Scheduler {
+
+    /// The time type used by the immediate scheduler.
+    public struct SchedulerTimeType: Strideable {
+
+        fileprivate init() {}
+
+        /// Returns the distance to another immediate scheduler time; this distance is
+        /// always `0` in the context of an immediate scheduler.
+        ///
+        /// - Parameter other: The other scheduler time.
+        /// - Returns: `0`, as a `Stride`.
+        public func distance(to other: SchedulerTimeType) -> Stride { return 0 }
+
+        /// Advances the time by the specified amount; this is meaningless in the context
+        /// of an immediate scheduler.
+        ///
+        /// - Parameter n: The amount to advance by. The `ImmediateScheduler` ignores this
+        ///   value.
+        /// - Returns: An empty `SchedulerTimeType`.
+        public func advanced(by _: Stride) -> SchedulerTimeType {
+            return SchedulerTimeType()
+        }
+
+        /// The increment by which the immediate scheduler counts time.
+        public struct Stride: ExpressibleByFloatLiteral,
+                              Comparable,
+                              SignedNumeric,
+                              Codable,
+                              SchedulerTimeIntervalConvertible {
+
+            /// The type used when evaluating floating-point literals.
+            public typealias FloatLiteralType = Double
+
+            /// The type used when evaluating integer literals.
+            public typealias IntegerLiteralType = Int
+
+            /// The type used for expressing the stride’s magnitude.
+            public typealias Magnitude = Int
+
+            /// The value of this time interval in seconds.
+            public var magnitude: Int
+
+            /// Creates an immediate scheduler time interval from the given time interval.
+            @inlinable
+            public init(_ value: Int) {
+                magnitude = value
+            }
+
+            /// Creates an immediate scheduler time interval from an integer seconds
+            /// value.
+            @inlinable
+            public init(integerLiteral value: Int) {
+                self.init(value)
+            }
+
+            /// Creates an immediate scheduler time interval from a floating-point seconds
+            /// value.
+            @inlinable
+            public init(floatLiteral value: Double) {
+                self.init(Int(value))
+            }
+
+            /// Creates an immediate scheduler time interval from a binary integer type.
+            ///
+            /// If `exactly` can’t convert to an `Int`, the resulting time interval is
+            /// `nil`.
+            @inlinable
+            public init?<BinaryIntegerType: BinaryInteger>(
+                exactly source: BinaryIntegerType
+            ) {
+                guard let magnitude = Int(exactly: source) else {
+                    return nil
+                }
+                self.init(magnitude)
+            }
+
+            @inlinable
+            public static func < (lhs: Stride, rhs: Stride) -> Bool {
+                return lhs.magnitude < rhs.magnitude
+            }
+
+            @inlinable
+            public static func * (lhs: Stride, rhs: Stride) -> Stride {
+                return Stride(lhs.magnitude * rhs.magnitude)
+            }
+
+            @inlinable
+            public static func + (lhs: Stride, rhs: Stride) -> Stride {
+                return Stride(lhs.magnitude + rhs.magnitude)
+            }
+
+            @inlinable
+            public static func - (lhs: Stride, rhs: Stride) -> Stride {
+                return Stride(lhs.magnitude - rhs.magnitude)
+            }
+
+            @inlinable
+            public static func -= (lhs: inout Stride, rhs: Stride) {
+                lhs.magnitude -= rhs.magnitude
+            }
+
+            public static func *= (lhs: inout Stride, rhs: Stride) {
+                lhs.magnitude *= rhs.magnitude
+            }
+
+            public static func += (lhs: inout Stride, rhs: Stride) {
+                lhs.magnitude += rhs.magnitude
+            }
+
+            public static func seconds(_: Int) -> Stride { return 0 }
+
+            public static func seconds(_: Double) -> Stride { return 0 }
+
+            public static func milliseconds(_: Int) -> Stride { return 0 }
+
+            public static func microseconds(_: Int) -> Stride { return 0 }
+
+            public static func nanoseconds(_: Int) -> Stride { return 0 }
+        }
+    }
+
+    /// A type that defines options accepted by the immediate scheduler.
+    public typealias SchedulerOptions = Never
+
+    /// The shared instance of the immediate scheduler.
+    ///
+    /// You cannot create instances of the immediate scheduler yourself. Use only
+    /// the shared instance.
+    public static let shared = ImmediateScheduler()
+
+    /// Performs the action at the next possible opportunity.
+    @inlinable
+    public func schedule(options: SchedulerOptions?, _ action: @escaping () -> Void) {
+        action()
+    }
+
+    /// The immediate scheduler’s definition of the current moment in time.
+    public var now: SchedulerTimeType { return SchedulerTimeType() }
+
+    /// The minimum tolerance allowed by the immediate scheduler.
+    public var minimumTolerance: SchedulerTimeType.Stride { return 0 }
+
+    /// Performs the action at some time after the specified date.
+    ///
+    /// The immediate scheduler ignores `date` and performs the action immediately.
+    public func schedule(after date: SchedulerTimeType,
+                         tolerance: SchedulerTimeType.Stride,
+                         options: SchedulerOptions?,
+                         _ action: @escaping () -> Void) {
+        action()
+    }
+
+    /// Performs the action at some time after the specified date, at the specified
+    /// frequency, optionally taking into account tolerance if possible.
+    ///
+    /// The immediate scheduler ignores `date` and performs the action immediately.
+    public func schedule(after date: SchedulerTimeType,
+                         interval: SchedulerTimeType.Stride,
+                         tolerance: SchedulerTimeType.Stride,
+                         options: SchedulerOptions?,
+                         _ action: @escaping () -> Void) -> Cancellable {
+        action()
+        return Subscriptions.empty
+    }
+}

package/Sources/Combine/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Sergej Jaskiewicz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Sources/Combine/NotificationPublisher.swift

@@ -0,0 +1,48 @@
+// `NotificationCenter.default.publisher(for:)` as a Combine publisher, as
+// Apple's Foundation makes it: subscribers receive the matching
+// notifications, as many as they have asked for, until they cancel.
+// (FoundationBridge declares the publisher, which SwiftUI's `onReceive` takes
+// without Combine.)
+
+import Foundation
+import FoundationBridge
+
+extension FoundationBridge.NotificationCenter.Publisher: Publisher {
+    public typealias Failure = Never
+
+    public func receive<S: Subscriber>(subscriber: S) where S.Input == Notification, S.Failure == Never {
+        subscriber.receive(subscription: NotificationSubscription(subscriber: subscriber, publisher: self))
+    }
+}
+
+private final class NotificationSubscription<Downstream: Subscriber>: Subscription, @unchecked Sendable
+where Downstream.Input == Notification, Downstream.Failure == Never {
+    private var downstream: Downstream?
+    private var demand = Subscribers.Demand.none
+    private let center: FoundationBridge.NotificationCenter
+    private var token: (any NSObjectProtocol)?
+
+    init(subscriber: Downstream, publisher: FoundationBridge.NotificationCenter.Publisher) {
+        downstream = subscriber
+        center = publisher.center
+        token = publisher.center.addObserver(forName: publisher.name, object: publisher.object, queue: nil) { [weak self] note in
+            self?.deliver(note)
+        }
+    }
+
+    func request(_ demand: Subscribers.Demand) {
+        self.demand += demand
+    }
+
+    private func deliver(_ note: Notification) {
+        guard let downstream, demand > 0 else { return }
+        demand -= 1
+        demand += downstream.receive(note)
+    }
+
+    func cancel() {
+        if let token { center.removeObserver(token) }
+        token = nil
+        downstream = nil
+    }
+}

package/Sources/Combine/ObjectWillChange.swift

@@ -0,0 +1,46 @@
+// `objectWillChange` as a Combine publisher. The SwiftUI shim's
+// `ObservableObjectPublisher` tells the views that observe its object; this
+// makes it a `Publisher` of `Void` too, so `object.objectWillChange.sink { }`
+// (ButtonKit forwards one model's changes to another this way) and the
+// operators work. A subscriber hears every `send()` while it has demand,
+// until it cancels.
+
+import SwiftUI
+
+extension ObservableObjectPublisher: Publisher {
+    public typealias Output = Void
+    public typealias Failure = Never
+
+    public func receive<S: Subscriber>(subscriber: S) where S.Input == Void, S.Failure == Never {
+        subscriber.receive(subscription: ObjectWillChangeSubscription(publisher: self, subscriber: subscriber))
+    }
+}
+
+private final class ObjectWillChangeSubscription<S: Subscriber>: Subscription where S.Input == Void, S.Failure == Never {
+    private weak var publisher: ObservableObjectPublisher?
+    private var subscriber: S?
+    private var token: AnyObject?
+    private var demand = Subscribers.Demand.none
+
+    init(publisher: ObservableObjectPublisher, subscriber: S) {
+        self.publisher = publisher
+        self.subscriber = subscriber
+        token = publisher._subscribe { [weak self] in self?.receive() }
+    }
+
+    private func receive() {
+        guard demand > 0, let subscriber else { return }
+        demand -= 1
+        demand += subscriber.receive(())
+    }
+
+    func request(_ demand: Subscribers.Demand) {
+        self.demand += demand
+    }
+
+    func cancel() {
+        if let token { publisher?._unsubscribe(token) }
+        token = nil
+        subscriber = nil
+    }
+}

package/Sources/Combine/PassthroughSubject.swift

@@ -0,0 +1,222 @@
+//
+//  PassthroughSubject.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 11.06.2019.
+//
+
+/// A subject that broadcasts elements to downstream subscribers.
+///
+/// As a concrete implementation of `Subject`, the `PassthroughSubject` provides
+/// a convenient way to adapt existing imperative code to the Combine model.
+///
+/// Unlike `CurrentValueSubject`, a `PassthroughSubject` doesn’t have an initial value or
+/// a buffer of the most recently-published element.
+/// A `PassthroughSubject` drops values if there are no subscribers, or its current demand
+/// is zero.
+public final class PassthroughSubject<Output, Failure: Error>: Subject {
+
+    private let lock = UnfairLock.allocate()
+
+    private var active = true
+
+    private var completion: Subscribers.Completion<Failure>?
+
+    private var downstreams = ConduitList<Output, Failure>.empty
+
+    internal var upstreamSubscriptions: [Subscription] = []
+
+    internal var hasAnyDownstreamDemand = false
+
+    public init() {}
+
+    deinit {
+        for subscription in upstreamSubscriptions {
+            subscription.cancel()
+        }
+        lock.deallocate()
+    }
+
+    public func send(subscription: Subscription) {
+        lock.lock()
+        upstreamSubscriptions.append(subscription)
+        let hasAnyDownstreamDemand = self.hasAnyDownstreamDemand
+        lock.unlock()
+        if hasAnyDownstreamDemand {
+            subscription.request(.unlimited)
+        }
+    }
+
+    public func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Output == Downstream.Input, Failure == Downstream.Failure
+    {
+        lock.lock()
+        if active {
+            let conduit = Conduit(parent: self, downstream: subscriber)
+            downstreams.insert(conduit)
+            lock.unlock()
+            subscriber.receive(subscription: conduit)
+        } else {
+            let completion = self.completion!
+            lock.unlock()
+            subscriber.receive(subscription: Subscriptions.empty)
+            subscriber.receive(completion: completion)
+        }
+    }
+
+    public func send(_ input: Output) {
+        lock.lock()
+        guard active else {
+            lock.unlock()
+            return
+        }
+        let downstreams = self.downstreams
+        lock.unlock()
+        downstreams.forEach { conduit in
+            conduit.offer(input)
+        }
+    }
+
+    public func send(completion: Subscribers.Completion<Failure>) {
+        lock.lock()
+        guard active else {
+            lock.unlock()
+            return
+        }
+        active = false
+        self.completion = completion
+        let downstreams = self.downstreams.take()
+        lock.unlock()
+        downstreams.forEach { conduit in
+            conduit.finish(completion: completion)
+        }
+    }
+
+    private func acknowledgeDownstreamDemand() {
+        lock.lock()
+        if hasAnyDownstreamDemand {
+            lock.unlock()
+            return
+        }
+        hasAnyDownstreamDemand = true
+        let upstreamSubscriptions = self.upstreamSubscriptions
+        lock.unlock()
+        for subscription in upstreamSubscriptions {
+            subscription.request(.unlimited)
+        }
+    }
+
+    private func disassociate(_ conduit: ConduitBase<Output, Failure>) {
+        lock.lock()
+        guard active else {
+            lock.unlock()
+            return
+        }
+        downstreams.remove(conduit)
+        lock.unlock()
+    }
+}
+
+extension PassthroughSubject {
+
+    private final class Conduit<Downstream: Subscriber>
+        : ConduitBase<Output, Failure>,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Output, Downstream.Failure == Failure
+    {
+
+        fileprivate var parent: PassthroughSubject?
+
+        fileprivate var downstream: Downstream?
+
+        fileprivate var demand = Subscribers.Demand.none
+
+        private var lock = UnfairLock.allocate()
+
+        private var downstreamLock = UnfairRecursiveLock.allocate()
+
+        fileprivate init(parent: PassthroughSubject,
+                         downstream: Downstream) {
+            self.parent = parent
+            self.downstream = downstream
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        override func offer(_ output: Output) {
+            lock.lock()
+            guard demand > 0, let downstream = self.downstream else {
+                lock.unlock()
+                return
+            }
+            demand -= 1
+            lock.unlock()
+            downstreamLock.lock()
+            let newDemand = downstream.receive(output)
+            downstreamLock.unlock()
+            guard newDemand > 0 else { return }
+            lock.lock()
+            demand += newDemand
+            lock.unlock()
+        }
+
+        override func finish(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard let downstream = self.downstream.take() else {
+                lock.unlock()
+                return
+            }
+            let parent = self.parent.take()
+            lock.unlock()
+            parent?.disassociate(self)
+            downstreamLock.lock()
+            downstream.receive(completion: completion)
+            downstreamLock.unlock()
+        }
+
+        override func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            lock.lock()
+            if self.downstream == nil {
+                lock.unlock()
+                return
+            }
+            self.demand += demand
+            let parent = self.parent
+            lock.unlock()
+            parent?.acknowledgeDownstreamDemand()
+        }
+
+        override func cancel() {
+            lock.lock()
+            if downstream.take() == nil {
+                lock.unlock()
+                return
+            }
+            let parent = self.parent.take()
+            lock.unlock()
+            parent?.disassociate(self)
+        }
+
+        var description: String { return "PassthroughSubject" }
+
+        var customMirror: Mirror {
+            lock.lock()
+            defer { lock.unlock() }
+            let children: [Mirror.Child] = [
+                ("parent", parent as Any),
+                ("downstream", downstream as Any),
+                ("demand", demand),
+                ("subject", parent as Any)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

package/Sources/Combine/Publisher+Subscribe.swift

@@ -0,0 +1,53 @@
+//
+//  Publisher+Subscribe.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 23.04.2023.
+//
+
+extension Publisher {
+
+    /// Attaches the specified subscriber to this publisher.
+    ///
+    /// Always call this function instead of `receive(subscriber:)`.
+    /// Adopters of `Publisher` must implement `receive(subscriber:)`.
+    /// The implementation of `subscribe(_:)` in this extension calls through to
+    /// `receive(subscriber:)`.
+    /// - SeeAlso: `receive(subscriber:)`
+    /// - Parameters:
+    ///     - subscriber: The subscriber to attach to this `Publisher`. After attaching,
+    ///       the subscriber can start to receive values.
+    public func subscribe<Subscriber: Combine.Subscriber>(_ subscriber: Subscriber)
+        where Failure == Subscriber.Failure, Output == Subscriber.Input
+    {
+        if let hook = DebugHook.getGlobalHook() {
+            if var marker = subscriber as? SubscriberTapMarker {
+                let anySubscriber = marker.inner
+                    as! AnySubscriber<Subscriber.Input, Subscriber.Failure>
+                hook.willReceive(publisher: self, subscriber: anySubscriber)
+                receive(subscriber: subscriber)
+                hook.didReceive(publisher: self, subscriber: anySubscriber)
+            } else {
+                let tap = SubscriberTap(subscriber: subscriber)
+                hook.willReceive(publisher: self, subscriber: subscriber)
+                receive(subscriber: tap)
+                hook.didReceive(publisher: self, subscriber: subscriber)
+            }
+        } else {
+            receive(subscriber: subscriber)
+        }
+    }
+
+    /// Attaches the specified subject to this publisher.
+    ///
+    /// - Parameter subject: The subject to attach to this publisher.
+    public func subscribe<Subject: Combine.Subject>(
+        _ subject: Subject
+    ) -> AnyCancellable
+        where Failure == Subject.Failure, Output == Subject.Output
+    {
+        let subscriber = SubjectSubscriber(subject)
+        self.subscribe(subscriber)
+        return AnyCancellable(subscriber)
+    }
+}

package/Sources/Combine/Publishers/Deferred.swift

@@ -0,0 +1,48 @@
+//
+//  Deferred.swift
+//  
+//
+//  Created by Joseph Spadafora on 7/7/19.
+//
+
+/// A publisher that awaits subscription before running the supplied closure
+/// to create a publisher for the new subscriber.
+public struct Deferred<DeferredPublisher: Publisher>: Publisher {
+
+    /// The kind of values published by this publisher.
+    public typealias Output = DeferredPublisher.Output
+
+    /// The kind of errors this publisher might publish.
+    ///
+    /// Use `Never` if this `Publisher` does not publish errors.
+    public typealias Failure = DeferredPublisher.Failure
+
+    /// The closure to execute when this deferred publisher receives a subscription.
+    ///
+    /// The publisher returned by this closure immediately
+    /// receives the incoming subscription.
+    public let createPublisher: () -> DeferredPublisher
+
+    /// Creates a deferred publisher.
+    ///
+    /// - Parameter createPublisher: The closure to execute
+    /// when calling `subscribe(_:)`.
+    public init(createPublisher: @escaping () -> DeferredPublisher) {
+        self.createPublisher = createPublisher
+    }
+
+    /// 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.
+    public func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Failure == Downstream.Failure,
+              Output == Downstream.Input
+    {
+        let deferredPublisher = createPublisher()
+        deferredPublisher.subscribe(subscriber)
+    }
+}

package/Sources/Combine/Publishers/Empty.swift

@@ -0,0 +1,54 @@
+//
+//  Empty.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 16.06.2019.
+//
+
+/// A publisher that never publishes any values, and optionally finishes immediately.
+///
+/// You can create a ”Never” publisher — one which never sends values and never
+/// finishes or fails — with the initializer `Empty(completeImmediately: false)`.
+public struct Empty<Output, Failure: Error>: Publisher, Equatable {
+
+    /// Creates an empty publisher.
+    ///
+    /// - Parameter completeImmediately: A Boolean value that indicates whether
+    ///   the publisher should immediately finish.
+    public init(completeImmediately: Bool = true) {
+        self.completeImmediately = completeImmediately
+    }
+
+    /// Creates an empty publisher with the given completion behavior and output and
+    /// failure types.
+    ///
+    /// Use this initializer to connect the empty publisher to subscribers or other
+    /// publishers that have specific output and failure types.
+    /// 
+    /// - Parameters:
+    ///   - completeImmediately: A Boolean value that indicates whether the publisher
+    ///     should immediately finish.
+    ///   - outputType: The output type exposed by this publisher.
+    ///   - failureType: The failure type exposed by this publisher.
+    public init(completeImmediately: Bool = true,
+                outputType: Output.Type,
+                failureType: Failure.Type) {
+        self.init(completeImmediately: completeImmediately)
+    }
+
+    /// A Boolean value that indicates whether the publisher immediately sends
+    /// a completion.
+    ///
+    /// If `true`, the publisher finishes immediately after sending a subscription
+    /// to the subscriber. If `false`, it never completes.
+    public let completeImmediately: Bool
+
+    public func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Output == Downstream.Input, Failure == Downstream.Failure
+    {
+        subscriber.receive(subscription: Subscriptions.empty)
+        if completeImmediately {
+            subscriber.receive(completion: .finished)
+        }
+    }
+}