@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/UIKit/ShortcutItems.swift

@@ -0,0 +1,67 @@
+// Home Screen quick actions (`UIApplicationShortcutItem`). A web page has no
+// Home Screen icon menu, so the items an app sets are kept and never shown,
+// and no shortcut ever launches the app.
+
+import Foundation
+
+public final class UIApplicationShortcutIcon: Hashable, @unchecked Sendable {
+    public enum IconType: Int, Sendable {
+        case compose, play, pause, add, location, search, share, prohibit, contact, home, markLocation,
+             favorite, love, cloud, invitation, confirmation, mail, message, date, time, capturePhoto,
+             captureVideo, task, taskCompleted, alarm, bookmark, shuffle, audio, update
+    }
+
+    enum Source: Hashable {
+        case type(IconType)
+        case systemImage(String)
+        case templateImage(String)
+    }
+
+    let source: Source
+
+    public init(type: IconType) { source = .type(type) }
+    public init(systemImageName: String) { source = .systemImage(systemImageName) }
+    public init(templateImageName: String) { source = .templateImage(templateImageName) }
+
+    public static func == (lhs: UIApplicationShortcutIcon, rhs: UIApplicationShortcutIcon) -> Bool { lhs.source == rhs.source }
+    public func hash(into hasher: inout Hasher) { hasher.combine(source) }
+}
+
+public class UIApplicationShortcutItem: Hashable, @unchecked Sendable {
+    public let type: String
+    public let localizedTitle: String
+    public let localizedSubtitle: String?
+    public let icon: UIApplicationShortcutIcon?
+    public let userInfo: [String: any NSSecureCoding]?
+    public var targetContentIdentifier: Any?
+
+    public init(type: String, localizedTitle: String, localizedSubtitle: String? = nil,
+                icon: UIApplicationShortcutIcon? = nil, userInfo: [String: any NSSecureCoding]? = nil) {
+        self.type = type
+        self.localizedTitle = localizedTitle
+        self.localizedSubtitle = localizedSubtitle
+        self.icon = icon
+        self.userInfo = userInfo
+    }
+
+    public convenience init(type: String, localizedTitle: String) {
+        self.init(type: type, localizedTitle: localizedTitle, localizedSubtitle: nil, icon: nil, userInfo: nil)
+    }
+
+    public static func == (lhs: UIApplicationShortcutItem, rhs: UIApplicationShortcutItem) -> Bool {
+        lhs.type == rhs.type && lhs.localizedTitle == rhs.localizedTitle && lhs.localizedSubtitle == rhs.localizedSubtitle && lhs.icon == rhs.icon
+    }
+    public func hash(into hasher: inout Hasher) { hasher.combine(type); hasher.combine(localizedTitle) }
+}
+
+public final class UIMutableApplicationShortcutItem: UIApplicationShortcutItem, @unchecked Sendable {}
+
+nonisolated(unsafe) private var _shortcutItems: [UIApplicationShortcutItem]? = nil
+
+extension UIApplication {
+    /// Kept, never shown: the page has no Home Screen quick actions.
+    public var shortcutItems: [UIApplicationShortcutItem]? {
+        get { _shortcutItems }
+        set { _shortcutItems = newValue }
+    }
+}

package/Sources/UIKit/SymbolConfiguration.swift

@@ -0,0 +1,124 @@
+// UIImage's symbol configurations (point size, weight, scale, text style,
+// colors) and the `UIImage(systemName:…)` initializers that take one, which
+// symbol helpers such as SFSafeSymbols and App Intents' display images
+// forward to. A configuration keeps its values; the image is the plain
+// symbol, which the page draws at the size and color of where it is shown.
+
+import Foundation
+import SwiftUI
+
+extension UIImage {
+    /// An image configuration: its traits, kept.
+    open class Configuration: @unchecked Sendable {
+        public fileprivate(set) var traitCollection: UITraitCollection?
+
+        public required init() {}
+
+        public func withTraitCollection(_ traitCollection: UITraitCollection?) -> Self {
+            let copy = self.copy()
+            copy.traitCollection = traitCollection
+            return copy
+        }
+
+        public func applying(_ otherConfiguration: UIImage.Configuration?) -> Self {
+            let copy = self.copy()
+            if let other = otherConfiguration { copy.merge(other) }
+            return copy
+        }
+
+        func copy() -> Self {
+            let copy = Self.init()
+            copy.merge(self)
+            return copy
+        }
+
+        /// Takes the values `other` sets.
+        func merge(_ other: Configuration) {
+            traitCollection = other.traitCollection ?? traitCollection
+        }
+    }
+
+    /// A symbol's configuration: point size, weight, scale, text style and colors, kept.
+    open class SymbolConfiguration: Configuration, @unchecked Sendable {
+        public private(set) var pointSize: CGFloat?
+        public private(set) var weight: SymbolWeight?
+        public private(set) var scale: SymbolScale?
+        public private(set) var textStyle: UIFont.TextStyle?
+        public private(set) var colors: [UIColor] = []
+        public private(set) var prefersMulticolor = false
+
+        public required init() {}
+
+        public convenience init(pointSize: CGFloat) { self.init(); self.pointSize = pointSize }
+        public convenience init(weight: SymbolWeight) { self.init(); self.weight = weight }
+        public convenience init(scale: SymbolScale) { self.init(); self.scale = scale }
+        public convenience init(pointSize: CGFloat, weight: SymbolWeight, scale: SymbolScale = .default) {
+            self.init(); self.pointSize = pointSize; self.weight = weight; self.scale = scale
+        }
+        public convenience init(textStyle: UIFont.TextStyle) { self.init(); self.textStyle = textStyle }
+        public convenience init(textStyle: UIFont.TextStyle, scale: SymbolScale) { self.init(); self.textStyle = textStyle; self.scale = scale }
+        public convenience init(font: UIFont) { self.init(); self.pointSize = font.pointSize }
+        public convenience init(font: UIFont, scale: SymbolScale) { self.init(); self.pointSize = font.pointSize; self.scale = scale }
+        public convenience init(hierarchicalColor: UIColor) { self.init(); self.colors = [hierarchicalColor] }
+        public convenience init(paletteColors: [UIColor]) { self.init(); self.colors = paletteColors }
+
+        public static var unspecified: SymbolConfiguration { SymbolConfiguration() }
+        public class func configurationPreferringMulticolor() -> SymbolConfiguration {
+            let configuration = SymbolConfiguration()
+            configuration.prefersMulticolor = true
+            return configuration
+        }
+        public class func configurationWithHierarchicalColor(_ color: UIColor) -> SymbolConfiguration { .init(hierarchicalColor: color) }
+        public class func configurationWithPaletteColors(_ colors: [UIColor]) -> SymbolConfiguration { .init(paletteColors: colors) }
+
+        public func configurationWithoutPointSizeAndWeight() -> SymbolConfiguration {
+            let copy = self.copy()
+            copy.pointSize = nil
+            copy.weight = nil
+            return copy
+        }
+
+        override func merge(_ other: Configuration) {
+            super.merge(other)
+            guard let other = other as? SymbolConfiguration else { return }
+            pointSize = other.pointSize ?? pointSize
+            weight = other.weight ?? weight
+            scale = other.scale ?? scale
+            textStyle = other.textStyle ?? textStyle
+            colors = other.colors.isEmpty ? colors : other.colors
+            prefersMulticolor = other.prefersMulticolor || prefersMulticolor
+        }
+
+        public func isEqual(to otherConfiguration: SymbolConfiguration?) -> Bool {
+            guard let other = otherConfiguration else { return false }
+            return pointSize == other.pointSize && weight == other.weight && scale == other.scale
+                && textStyle == other.textStyle && colors == other.colors && prefersMulticolor == other.prefersMulticolor
+        }
+    }
+
+    public enum SymbolWeight: Int, Sendable {
+        case unspecified = 0, ultraLight, thin, light, regular, medium, semibold, bold, heavy, black
+    }
+
+    public enum SymbolScale: Int, Sendable {
+        case `default` = -1, unspecified = 0, small, medium, large
+    }
+
+    /// The symbol; the configuration does not change how the page draws it.
+    public convenience init?(systemName name: String, withConfiguration configuration: UIImage.Configuration?) {
+        self.init(systemName: name)
+    }
+
+    public convenience init?(systemName name: String, compatibleWith traitCollection: UITraitCollection?) {
+        self.init(systemName: name)
+    }
+
+    /// The symbol; the page draws variable symbols fully filled.
+    public convenience init?(systemName name: String, variableValue: Double, configuration: UIImage.Configuration?) {
+        self.init(systemName: name)
+    }
+
+    public func withConfiguration(_ configuration: UIImage.Configuration) -> UIImage { self }
+    public func applyingSymbolConfiguration(_ configuration: UIImage.SymbolConfiguration) -> UIImage? { self }
+    public var symbolConfiguration: UIImage.SymbolConfiguration? { nil }
+}

package/Sources/UIKit/TargetAction.swift

@@ -0,0 +1,123 @@
+// UIKit's target/action APIs, with FoundationBridge's `Selector` (which the
+// staging makes from `#selector`): `CADisplayLink`, which calls its target
+// once a frame, and `UIControl`'s actions. The views draw nothing, but code
+// that drives animation or state from them runs.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+/// Calls its target once a frame (60 a second, on the executor's clock)
+/// while it is added to a run loop and not paused; a paused link runs no
+/// timer at all. Not tied to the main actor, as on iOS (any thread may make
+/// one); its target is called on the main run loop, the only one the page has.
+open class CADisplayLink: @unchecked Sendable {
+    private let target: AnyObject
+    private let selector: FoundationBridge.Selector
+    private var timer: FoundationBridge.Timer?
+    /// Added to a run loop and not invalidated since.
+    private var isAdded = false
+
+    open var isPaused = false { didSet { if isPaused != oldValue { schedule() } } }
+    open var preferredFramesPerSecond = 60 { didSet { schedule() } }
+    open var preferredFrameRateRange = CAFrameRateRange.default
+    public private(set) var timestamp: CFTimeInterval = 0
+    public private(set) var targetTimestamp: CFTimeInterval = 0
+    open var duration: CFTimeInterval { 1 / Double(max(1, preferredFramesPerSecond)) }
+
+    public init(target: Any, selector sel: FoundationBridge.Selector) {
+        self.target = target as AnyObject
+        selector = sel
+    }
+
+    open func add(to runloop: FoundationBridge.RunLoop, forMode mode: FoundationBridge.RunLoop.Mode) {
+        guard !isAdded else { return }
+        isAdded = true
+        schedule()
+    }
+
+    open func remove(from runloop: FoundationBridge.RunLoop, forMode mode: FoundationBridge.RunLoop.Mode) { invalidate() }
+
+    open func invalidate() {
+        isAdded = false
+        schedule()
+    }
+
+    /// A timer while the link is added and not paused, none otherwise.
+    private func schedule() {
+        timer?.invalidate()
+        timer = nil
+        guard isAdded, !isPaused else { return }
+        nonisolated(unsafe) let link = self
+        timer = FoundationBridge.Timer.scheduledTimer(withTimeInterval: duration, repeats: true) { _ in
+            let now = FoundationBridge.CFAbsoluteTimeGetCurrent()
+            link.timestamp = now
+            link.targetTimestamp = now + link.duration
+            link.selector._perform(on: link.target, with: link)
+        }
+    }
+}
+
+/// The frame rates a display link would like.
+public struct CAFrameRateRange: Hashable, Sendable {
+    public var minimum: Float
+    public var maximum: Float
+    public var preferred: Float?
+    public init(minimum: Float, maximum: Float, preferred: Float? = nil) {
+        self.minimum = minimum
+        self.maximum = maximum
+        self.preferred = preferred
+    }
+    public static let `default` = CAFrameRateRange(minimum: 0, maximum: 0, preferred: 0)
+}
+
+/// A control: its state and the actions its events send.
+@MainActor
+open class UIControl: UIView {
+    public struct Event: OptionSet, Hashable, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let touchDown = Event(rawValue: 1 << 0)
+        public static let touchDownRepeat = Event(rawValue: 1 << 1)
+        public static let touchDragInside = Event(rawValue: 1 << 2)
+        public static let touchDragOutside = Event(rawValue: 1 << 3)
+        public static let touchUpInside = Event(rawValue: 1 << 6)
+        public static let touchUpOutside = Event(rawValue: 1 << 7)
+        public static let touchCancel = Event(rawValue: 1 << 8)
+        public static let valueChanged = Event(rawValue: 1 << 12)
+        public static let primaryActionTriggered = Event(rawValue: 1 << 13)
+        public static let editingDidBegin = Event(rawValue: 1 << 16)
+        public static let editingChanged = Event(rawValue: 1 << 17)
+        public static let editingDidEnd = Event(rawValue: 1 << 18)
+        public static let editingDidEndOnExit = Event(rawValue: 1 << 19)
+        public static let allTouchEvents = Event(rawValue: 0x0000_0FFF)
+        public static let allEditingEvents = Event(rawValue: 0x000F_0000)
+        public static let allEvents = Event(rawValue: 0xFFFF_FFFF)
+    }
+
+    open var isEnabled = true
+    open var isSelected = false
+    open var isHighlighted = false
+
+    private var actions: [(target: AnyObject?, action: FoundationBridge.Selector, events: Event)] = []
+
+    open func addTarget(_ target: Any?, action: FoundationBridge.Selector, for controlEvents: Event) {
+        actions.append((target.map { $0 as AnyObject }, action, controlEvents))
+    }
+
+    open func removeTarget(_ target: Any?, action: FoundationBridge.Selector?, for controlEvents: Event) {
+        let object = target.map { $0 as AnyObject }
+        actions.removeAll { entry in
+            (object == nil || entry.target === object) && (action == nil || entry.action == action) && !entry.events.isDisjoint(with: controlEvents)
+        }
+    }
+
+    open var allTargets: Set<AnyHashable> { Set(actions.compactMap { $0.target.map { ObjectIdentifier($0) } }) }
+
+    /// Sends the actions registered for `controlEvents` (with the control as the sender).
+    open func sendActions(for controlEvents: Event) {
+        for entry in actions where !entry.events.isDisjoint(with: controlEvents) {
+            if let target = entry.target { entry.action._perform(on: target, with: self) }
+        }
+    }
+}

package/Sources/UIKit/TextPaste.swift

@@ -0,0 +1,161 @@
+// UIKit's paste customization: a text view's `pasteDelegate` may turn
+// pasted items into text, attributed text, or nothing (an app that takes a
+// pasted image as an attachment). In the browser the viewer pastes into the
+// text area the page shows for an editable `UITextView`, and the browser
+// inserts the clipboard's text itself; the edit reaches the app as any
+// typing does (`textViewDidChange`). The page does not hand pasted images to
+// the app yet, so the delegate is never consulted. The types are here so an
+// app's delegate compiles and can be called directly (docs/ops-protocol.md,
+// "Sharing and media").
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+/// What a view accepts when something is pasted or dropped into it.
+open class UIPasteConfiguration: @unchecked Sendable {
+    open var acceptableTypeIdentifiers: [String]
+
+    public init() { acceptableTypeIdentifiers = [] }
+    public init(acceptableTypeIdentifiers: [String]) { self.acceptableTypeIdentifiers = acceptableTypeIdentifiers }
+    public convenience init(forAccepting aClass: any NSItemProviderReading.Type) {
+        self.init(acceptableTypeIdentifiers: aClass.readableTypeIdentifiersForItemProvider)
+    }
+
+    open func addAcceptableTypeIdentifiers(_ acceptableTypeIdentifiers: [String]) {
+        self.acceptableTypeIdentifiers += acceptableTypeIdentifiers
+    }
+
+    open func addTypeIdentifiers(forAccepting aClass: any NSItemProviderReading.Type) {
+        acceptableTypeIdentifiers += aClass.readableTypeIdentifiersForItemProvider
+    }
+}
+
+/// A responder that takes pastes.
+@MainActor
+public protocol UIPasteConfigurationSupporting: AnyObject {
+    var pasteConfiguration: UIPasteConfiguration? { get set }
+    func paste(itemProviders: [NSItemProvider])
+    func canPaste(_ itemProviders: [NSItemProvider]) -> Bool
+}
+
+extension UIPasteConfigurationSupporting {
+    public func paste(itemProviders: [NSItemProvider]) {}
+    public func canPaste(_ itemProviders: [NSItemProvider]) -> Bool {
+        guard let types = pasteConfiguration?.acceptableTypeIdentifiers else { return false }
+        return itemProviders.contains { provider in types.contains { provider.hasItemConformingToTypeIdentifier($0) } }
+    }
+}
+
+/// A text input that takes pastes and has a paste delegate.
+@MainActor
+public protocol UITextPasteConfigurationSupporting: UIPasteConfigurationSupporting {
+    var pasteDelegate: (any UITextPasteDelegate)? { get set }
+}
+
+extension UITextView: UITextPasteConfigurationSupporting {
+    /// Pastes the providers' text at the selection, as the page's own paste
+    /// does: each provider's string (or URL) in turn.
+    public func paste(itemProviders: [NSItemProvider]) {
+        for provider in itemProviders where provider.canLoadObject(ofClass: String.self) || provider.canLoadObject(ofClass: URL.self) {
+            let asURL = !provider.canLoadObject(ofClass: String.self)
+            let insert: @Sendable (String?) -> Void = { [weak self] text in
+                guard let text else { return }
+                Task { @MainActor in self?.insertText(text) }
+            }
+            if asURL {
+                provider.loadObject(ofClass: URL.self) { url, _ in insert(url?.absoluteString) }
+            } else {
+                provider.loadObject(ofClass: String.self) { string, _ in insert(string) }
+            }
+        }
+    }
+}
+
+/// One pasted item a paste delegate transforms: it sets a result (text,
+/// attributed text), none (the app took the item itself), or the default.
+@MainActor
+public protocol UITextPasteItem: AnyObject {
+    var itemProvider: NSItemProvider { get }
+    var localObject: Any? { get }
+    var defaultAttributes: [NSAttributedString.Key: Any] { get }
+    func setStringResult(_ string: String)
+    func setAttributedStringResult(_ string: NSAttributedString)
+    func setResult(string: String)
+    func setResult(attributedString: NSAttributedString)
+    func setNoResult()
+    func setDefaultResult()
+}
+
+extension UITextPasteItem {
+    public func setStringResult(_ string: String) { setResult(string: string) }
+    public func setAttributedStringResult(_ string: NSAttributedString) { setResult(attributedString: string) }
+}
+
+/// A pasted item and the result its delegate chose.
+@MainActor
+public final class _TextPasteItem: UITextPasteItem {
+    public enum Result {
+        case pending, string(String), attributedString(NSAttributedString), none, defaultResult
+    }
+
+    public let itemProvider: NSItemProvider
+    public let localObject: Any?
+    public let defaultAttributes: [NSAttributedString.Key: Any]
+    public private(set) var result = Result.pending
+
+    public init(itemProvider: NSItemProvider, localObject: Any? = nil, defaultAttributes: [NSAttributedString.Key: Any] = [:]) {
+        self.itemProvider = itemProvider
+        self.localObject = localObject
+        self.defaultAttributes = defaultAttributes
+    }
+
+    public func setResult(string: String) { result = .string(string) }
+    public func setResult(attributedString: NSAttributedString) { result = .attributedString(attributedString) }
+    public func setNoResult() { result = .none }
+    public func setDefaultResult() { result = .defaultResult }
+}
+
+/// What a text input's paste delegate is asked. Every method has a default
+/// (they are optional on iOS).
+@MainActor
+public protocol UITextPasteDelegate: AnyObject {
+    func textPasteConfigurationSupporting(_ textPasteConfigurationSupporting: any UITextPasteConfigurationSupporting,
+                                          transform item: any UITextPasteItem)
+    func textPasteConfigurationSupporting(_ textPasteConfigurationSupporting: any UITextPasteConfigurationSupporting,
+                                          combineItemAttributedStrings itemStrings: [NSAttributedString],
+                                          for textRange: UITextRange) -> NSAttributedString
+    func textPasteConfigurationSupporting(_ textPasteConfigurationSupporting: any UITextPasteConfigurationSupporting,
+                                          performPasteOf attributedString: NSAttributedString,
+                                          to textRange: UITextRange) -> UITextRange
+    func textPasteConfigurationSupporting(_ textPasteConfigurationSupporting: any UITextPasteConfigurationSupporting,
+                                          shouldAnimatePasteOf attributedString: NSAttributedString,
+                                          to textRange: UITextRange) -> Bool
+}
+
+extension UITextPasteDelegate {
+    public func textPasteConfigurationSupporting(_ textPasteConfigurationSupporting: any UITextPasteConfigurationSupporting,
+                                                 transform item: any UITextPasteItem) {
+        item.setDefaultResult()
+    }
+
+    public func textPasteConfigurationSupporting(_ textPasteConfigurationSupporting: any UITextPasteConfigurationSupporting,
+                                                 combineItemAttributedStrings itemStrings: [NSAttributedString],
+                                                 for textRange: UITextRange) -> NSAttributedString {
+        let combined = NSMutableAttributedString()
+        for string in itemStrings { combined.append(string) }
+        return combined
+    }
+
+    public func textPasteConfigurationSupporting(_ textPasteConfigurationSupporting: any UITextPasteConfigurationSupporting,
+                                                 performPasteOf attributedString: NSAttributedString,
+                                                 to textRange: UITextRange) -> UITextRange {
+        textRange
+    }
+
+    public func textPasteConfigurationSupporting(_ textPasteConfigurationSupporting: any UITextPasteConfigurationSupporting,
+                                                 shouldAnimatePasteOf attributedString: NSAttributedString,
+                                                 to textRange: UITextRange) -> Bool {
+        false
+    }
+}