@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/SymbolEffects.swift

@@ -0,0 +1,203 @@
+// SF Symbols' effects (the Symbols framework's types, which SwiftUI
+// re-exports on iOS, as here) and the modifiers that apply them:
+// `.symbolEffect(.pulse, isActive:)`, `.symbolEffect(.bounce, value:)`,
+// `.contentTransition(.symbolEffect(.replace))`. An effect keeps the options
+// it was built with. The page draws a symbol as a still glyph, with no
+// layers to animate, so the modifiers return the view unchanged: the symbol
+// shows, without the bounce, pulse or replacement animation.
+//
+// The Symbols module (Sources/Symbols) re-exports these types for files that
+// `import Symbols`.
+
+// MARK: - Effect kinds
+
+/// A symbol effect: its options, kept.
+public protocol SymbolEffect: Hashable, Sendable {}
+/// Plays once each time a value changes (`.symbolEffect(_:value:)`).
+public protocol DiscreteSymbolEffect: SymbolEffect {}
+/// Plays while active (`.symbolEffect(_:isActive:)`).
+public protocol IndefiniteSymbolEffect: SymbolEffect {}
+/// Shows or hides a symbol.
+public protocol TransitionSymbolEffect: SymbolEffect {}
+/// Replaces one symbol with another (`.contentTransition(.symbolEffect(…))`).
+public protocol ContentTransitionSymbolEffect: SymbolEffect {}
+
+/// How the effects below are built: a list of option names.
+public protocol _SymbolEffectOptions {
+    var _options: [String] { get }
+    init(_options: [String])
+}
+
+extension _SymbolEffectOptions {
+    func adding(_ option: String) -> Self { Self(_options: _options + [option]) }
+    public var byLayer: Self { adding("byLayer") }
+    public var wholeSymbol: Self { adding("wholeSymbol") }
+}
+
+public struct BounceSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+}
+
+public struct PulseSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+}
+
+public struct VariableColorSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var iterative: Self { adding("iterative") }
+    public var cumulative: Self { adding("cumulative") }
+    public var reversing: Self { adding("reversing") }
+    public var nonReversing: Self { adding("nonReversing") }
+    public var hideInactiveLayers: Self { adding("hideInactiveLayers") }
+    public var dimInactiveLayers: Self { adding("dimInactiveLayers") }
+}
+
+public struct ScaleSymbolEffect: IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+}
+
+public struct AppearSymbolEffect: TransitionSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+}
+
+public struct DisappearSymbolEffect: TransitionSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+}
+
+public struct ReplaceSymbolEffect: ContentTransitionSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var downUp: Self { adding("downUp") }
+    public var upUp: Self { adding("upUp") }
+    public var offUp: Self { adding("offUp") }
+    public func magic(fallback: ReplaceSymbolEffect) -> Self { adding("magic") }
+}
+
+public struct AutomaticSymbolEffect: ContentTransitionSymbolEffect, TransitionSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+}
+
+public struct BreatheSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var plain: Self { adding("plain") }
+    public var pulse: Self { adding("pulse") }
+}
+
+public struct RotateSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var clockwise: Self { adding("clockwise") }
+    public var counterClockwise: Self { adding("counterClockwise") }
+}
+
+public struct WiggleSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+    public var left: Self { adding("left") }
+    public var right: Self { adding("right") }
+    public var forward: Self { adding("forward") }
+    public var backward: Self { adding("backward") }
+    public var clockwise: Self { adding("clockwise") }
+    public var counterClockwise: Self { adding("counterClockwise") }
+    public static func custom(angle: Angle) -> Self { Self(_options: ["custom"]) }
+    public func custom(angle: Angle) -> Self { adding("custom") }
+}
+
+public struct DrawOnSymbolEffect: TransitionSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var individually: Self { adding("individually") }
+}
+
+public struct DrawOffSymbolEffect: TransitionSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var individually: Self { adding("individually") }
+}
+
+extension SymbolEffect where Self == BounceSymbolEffect { public static var bounce: BounceSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == PulseSymbolEffect { public static var pulse: PulseSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == VariableColorSymbolEffect { public static var variableColor: VariableColorSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == ScaleSymbolEffect { public static var scale: ScaleSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == AppearSymbolEffect { public static var appear: AppearSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == DisappearSymbolEffect { public static var disappear: DisappearSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == ReplaceSymbolEffect { public static var replace: ReplaceSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == AutomaticSymbolEffect { public static var automatic: AutomaticSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == BreatheSymbolEffect { public static var breathe: BreatheSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == RotateSymbolEffect { public static var rotate: RotateSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == WiggleSymbolEffect { public static var wiggle: WiggleSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == DrawOnSymbolEffect { public static var drawOn: DrawOnSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == DrawOffSymbolEffect { public static var drawOff: DrawOffSymbolEffect { .init(_options: []) } }
+
+/// How an effect plays: repeats and speed, kept.
+public struct SymbolEffectOptions: Hashable, Sendable {
+    public var repeatCount: Int?
+    public var isRepeating: Bool?
+    public var speed: Double = 1
+
+    public struct RepeatBehavior: Hashable, Sendable {
+        let count: Int?
+        public static let continuous = RepeatBehavior(count: nil)
+        public static func periodic(_ count: Int? = nil, delay: Double? = nil) -> RepeatBehavior { RepeatBehavior(count: count) }
+    }
+
+    public static let `default` = SymbolEffectOptions()
+    public static var repeating: SymbolEffectOptions { SymbolEffectOptions(isRepeating: true) }
+    public static var nonRepeating: SymbolEffectOptions { SymbolEffectOptions(isRepeating: false) }
+    public static func `repeat`(_ count: Int) -> SymbolEffectOptions { SymbolEffectOptions(repeatCount: count) }
+    public static func `repeat`(_ behavior: RepeatBehavior) -> SymbolEffectOptions { SymbolEffectOptions(isRepeating: true) }
+    public static func speed(_ speed: Double) -> SymbolEffectOptions { SymbolEffectOptions(speed: speed) }
+
+    public var repeating: SymbolEffectOptions { var copy = self; copy.isRepeating = true; return copy }
+    public var nonRepeating: SymbolEffectOptions { var copy = self; copy.isRepeating = false; return copy }
+    public func `repeat`(_ count: Int) -> SymbolEffectOptions { var copy = self; copy.repeatCount = count; return copy }
+    public func `repeat`(_ behavior: RepeatBehavior) -> SymbolEffectOptions { var copy = self; copy.isRepeating = true; return copy }
+    public func speed(_ speed: Double) -> SymbolEffectOptions { var copy = self; copy.speed = speed; return copy }
+}
+
+// MARK: - Modifiers
+
+nonisolated extension View {
+    /// The view unchanged: the page does not animate symbols.
+    public func symbolEffect<T: IndefiniteSymbolEffect>(_ effect: T, options: SymbolEffectOptions = .default, isActive: Bool = true) -> some View { self }
+
+    /// The view unchanged: the page does not animate symbols.
+    public func symbolEffect<T: DiscreteSymbolEffect, U: Equatable>(_ effect: T, options: SymbolEffectOptions = .default, value: U) -> some View { self }
+
+    public func symbolEffectsRemoved(_ isEnabled: Bool = true) -> some View { self }
+}
+
+extension ContentTransition {
+    /// A symbol replacement; the page swaps the symbol without animating it.
+    public static var symbolEffect: ContentTransition { ContentTransition(name: "symbolEffect") }
+    public static func symbolEffect<T: ContentTransitionSymbolEffect>(_ effect: T, options: SymbolEffectOptions = .default) -> ContentTransition {
+        ContentTransition(name: "symbolEffect")
+    }
+    /// Digits that roll to `value`; the page shows the new text without rolling.
+    public static func numericText(value: Double) -> ContentTransition { ContentTransition(name: "numericText") }
+}
+
+extension Image {
+    /// The symbol; the page draws variable symbols fully filled, whatever the value.
+    public init(systemName: String, variableValue: Double?) {
+        self.init(systemName: systemName)
+    }
+}