@expo/ui 56.0.7 → 56.0.9

package/ios/Modifiers/SwipeActionsModifier.swift

@@ -0,0 +1,97 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import SwiftUI
+
+internal enum SwipeActionsEdge: String, Enumerable {
+  case leading
+  case trailing
+
+  func toNativeEdge() -> HorizontalEdge {
+    switch self {
+    case .leading:
+      return .leading
+    case .trailing:
+      return .trailing
+    }
+  }
+}
+
+internal final class SwipeActionsViewProps: UIBaseViewProps {
+}
+
+private struct SwipeActionsSlot {
+  let edge: SwipeActionsEdge
+  let allowsFullSwipe: Bool
+  let view: SlotView
+}
+
+internal struct SwipeActionsView: ExpoSwiftUI.View {
+  @ObservedObject var props: SwipeActionsViewProps
+
+  var body: some View {
+    let child = props.children?.withoutSlots().first
+#if os(tvOS)
+    if let child {
+      let view: any View = child.childView
+      AnyView(view)
+    }
+#else
+    if let child {
+      let view: any View = child.childView
+      contentWithSwipeActions(AnyView(view))
+    }
+#endif
+  }
+
+#if !os(tvOS)
+  @ViewBuilder
+  private func contentWithSwipeActions(_ content: AnyView) -> some View {
+    let leading = actionSlot(for: .leading)
+    let trailing = actionSlot(for: .trailing)
+
+    if let leading, let trailing {
+      content
+        .swipeActions(edge: .leading, allowsFullSwipe: leading.allowsFullSwipe) {
+          leading.view
+        }
+        .swipeActions(edge: .trailing, allowsFullSwipe: trailing.allowsFullSwipe) {
+          trailing.view
+        }
+    } else if let leading {
+      content
+        .swipeActions(edge: .leading, allowsFullSwipe: leading.allowsFullSwipe) {
+          leading.view
+        }
+    } else if let trailing {
+      content
+        .swipeActions(edge: .trailing, allowsFullSwipe: trailing.allowsFullSwipe) {
+          trailing.view
+        }
+    } else {
+      content
+    }
+  }
+#endif
+
+  private func actionSlot(for edge: SwipeActionsEdge) -> SwipeActionsSlot? {
+    props.children?
+      .compactMap { $0.childView as? SlotView }
+      .compactMap(parseActionSlot)
+      .first { $0.edge == edge }
+  }
+
+  private func parseActionSlot(_ slot: SlotView) -> SwipeActionsSlot? {
+    guard slot.props.name == "actions",
+          let edgeName = slot.extra("edge", as: String.self),
+          let edge = SwipeActionsEdge(rawValue: edgeName) else {
+      return nil
+    }
+
+    return SwipeActionsSlot(
+      edge: edge,
+      allowsFullSwipe: slot.extra("allowsFullSwipe", as: Bool.self) ?? true,
+      view: slot
+    )
+  }
+}

package/ios/Modifiers/SymbolEffectModifier.swift

@@ -0,0 +1,452 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import SwiftUI
+
+// MARK: - Effect kind
+
+internal enum SymbolEffectKind: String, Enumerable {
+  case appear
+  case bounce
+  case breathe
+  case disappear
+  case drawOff
+  case drawOn
+  case pulse
+  case rotate
+  case scale
+  case variableColor
+  case wiggle
+}
+
+// MARK: - Effect option enums
+
+internal enum SymbolEffectScope: String, Enumerable {
+  case byLayer
+  case wholeSymbol
+  case individually
+}
+
+internal enum SymbolEffectDirection: String, Enumerable {
+  case up
+  case down
+  case left
+  case right
+  case forward
+  case backward
+  case clockwise
+  case counterClockwise
+}
+
+internal enum SymbolEffectScale: String, Enumerable {
+  case up
+  case down
+}
+
+internal enum SymbolEffectBreatheStyle: String, Enumerable {
+  case plain
+  case pulse
+}
+
+internal enum SymbolEffectFillStyle: String, Enumerable {
+  case iterative
+  case cumulative
+}
+
+internal enum SymbolEffectPlaybackStyle: String, Enumerable {
+  case reversing
+  case nonReversing
+  case reversed
+  case nonReversed
+}
+
+internal enum SymbolEffectInactiveLayers: String, Enumerable {
+  case dim
+  case hide
+}
+
+// MARK: - Options config
+
+internal enum SymbolEffectRepeatKind: String, Enumerable {
+  case continuous
+  case nonRepeating
+  case periodic
+}
+
+internal struct SymbolEffectOptionsConfig: Record {
+  @Field var repeatKind: SymbolEffectRepeatKind?
+  @Field var repeatCount: Int?
+  @Field var repeatDelay: Double?
+  @Field var speed: Double?
+
+  @available(iOS 17.0, tvOS 17.0, *)
+  func toSwiftUI() -> SymbolEffectOptions {
+    var options: SymbolEffectOptions = .default
+
+    switch repeatKind {
+    case .nonRepeating:
+      options = .nonRepeating
+    case .continuous:
+      if #available(iOS 18.0, tvOS 18.0, *) {
+        options = .repeat(.continuous)
+      }
+      // iOS 17: indefinite effects loop by default, so `.default` is fine here.
+    case .periodic:
+      if #available(iOS 18.0, tvOS 18.0, *) {
+        options = .repeat(.periodic(repeatCount, delay: repeatDelay))
+      }
+    case .none:
+      break
+    }
+
+    if let speed {
+      options = options.speed(speed)
+    }
+    return options
+  }
+}
+
+// MARK: - Effect config
+
+internal struct SymbolEffectConfig: Record {
+  @Field var effect: SymbolEffectKind = .pulse
+  @Field var direction: SymbolEffectDirection?
+  @Field var scale: SymbolEffectScale?
+  @Field var style: SymbolEffectBreatheStyle?
+  @Field var customAngle: Double?
+  @Field var fillStyle: SymbolEffectFillStyle?
+  @Field var playbackStyle: SymbolEffectPlaybackStyle?
+  @Field var inactiveLayers: SymbolEffectInactiveLayers?
+  @Field var scope: SymbolEffectScope?
+}
+
+// MARK: - Modifier
+
+internal struct SymbolEffectModifier: ViewModifier, Record {
+  @Field var effect: SymbolEffectConfig
+  @Field var options: SymbolEffectOptionsConfig?
+  @Field var isActive: ObservableState?
+  @Field var value: ObservableState?
+
+  @ViewBuilder
+  func body(content: Content) -> some View {
+    if #available(iOS 17.0, tvOS 17.0, *) {
+      let resolvedOptions = options?.toSwiftUI() ?? .default
+      if let value {
+        DiscreteEffectView(
+          config: effect,
+          options: resolvedOptions,
+          state: value
+        ) {
+          content
+        }
+      } else if let isActive {
+        IndefiniteEffectView(
+          config: effect,
+          options: resolvedOptions,
+          state: isActive
+        ) {
+          content
+        }
+      } else {
+        applyIndefiniteEffect(
+          to: content,
+          config: effect,
+          options: resolvedOptions,
+          isActive: true
+        )
+      }
+    } else {
+      content
+    }
+  }
+}
+
+// MARK: - Per-effect builders
+
+@available(iOS 17.0, tvOS 17.0, *)
+private func buildPulseEffect(_ config: SymbolEffectConfig) -> PulseSymbolEffect {
+  return switch config.scope {
+  case .byLayer: .pulse.byLayer
+  case .wholeSymbol: .pulse.wholeSymbol
+  default: .pulse
+  }
+}
+
+@available(iOS 17.0, tvOS 17.0, *)
+private func buildBounceEffect(_ config: SymbolEffectConfig) -> BounceSymbolEffect {
+  let directed: BounceSymbolEffect = switch config.direction {
+  case .up: .bounce.up
+  case .down: .bounce.down
+  default: .bounce
+  }
+  return switch config.scope {
+  case .byLayer: directed.byLayer
+  case .wholeSymbol: directed.wholeSymbol
+  default: directed
+  }
+}
+
+@available(iOS 17.0, tvOS 17.0, *)
+private func buildVariableColorEffect(_ config: SymbolEffectConfig) -> VariableColorSymbolEffect {
+  let filled: VariableColorSymbolEffect = switch config.fillStyle {
+  case .iterative: .variableColor.iterative
+  case .cumulative: .variableColor.cumulative
+  default: .variableColor
+  }
+  let playing: VariableColorSymbolEffect = switch config.playbackStyle {
+  case .reversing: filled.reversing
+  case .nonReversing: filled.nonReversing
+  default: filled
+  }
+  return switch config.inactiveLayers {
+  case .dim: playing.dimInactiveLayers
+  case .hide: playing.hideInactiveLayers
+  default: playing
+  }
+}
+
+@available(iOS 17.0, tvOS 17.0, *)
+private func buildScaleEffect(_ config: SymbolEffectConfig) -> ScaleSymbolEffect {
+  let scaled: ScaleSymbolEffect = switch config.scale {
+  case .up: .scale.up
+  case .down: .scale.down
+  default: .scale
+  }
+  return switch config.scope {
+  case .byLayer: scaled.byLayer
+  case .wholeSymbol: scaled.wholeSymbol
+  default: scaled
+  }
+}
+
+@available(iOS 17.0, tvOS 17.0, *)
+private func buildAppearEffect(_ config: SymbolEffectConfig) -> AppearSymbolEffect {
+  let scaled: AppearSymbolEffect = switch config.scale {
+  case .up: .appear.up
+  case .down: .appear.down
+  default: .appear
+  }
+  return switch config.scope {
+  case .byLayer: scaled.byLayer
+  case .wholeSymbol: scaled.wholeSymbol
+  default: scaled
+  }
+}
+
+@available(iOS 17.0, tvOS 17.0, *)
+private func buildDisappearEffect(_ config: SymbolEffectConfig) -> DisappearSymbolEffect {
+  let scaled: DisappearSymbolEffect = switch config.scale {
+  case .up: .disappear.up
+  case .down: .disappear.down
+  default: .disappear
+  }
+  return switch config.scope {
+  case .byLayer: scaled.byLayer
+  case .wholeSymbol: scaled.wholeSymbol
+  default: scaled
+  }
+}
+
+@available(iOS 18.0, tvOS 18.0, *)
+private func buildWiggleEffect(_ config: SymbolEffectConfig) -> WiggleSymbolEffect {
+  let directed: WiggleSymbolEffect = if let angle = config.customAngle {
+    .wiggle.custom(angle: angle)
+  } else {
+    switch config.direction {
+    case .up: .wiggle.up
+    case .down: .wiggle.down
+    case .left: .wiggle.left
+    case .right: .wiggle.right
+    case .forward: .wiggle.forward
+    case .backward: .wiggle.backward
+    case .clockwise: .wiggle.clockwise
+    case .counterClockwise: .wiggle.counterClockwise
+    default: .wiggle
+    }
+  }
+  return switch config.scope {
+  case .byLayer: directed.byLayer
+  case .wholeSymbol: directed.wholeSymbol
+  default: directed
+  }
+}
+
+@available(iOS 18.0, tvOS 18.0, *)
+private func buildBreatheEffect(_ config: SymbolEffectConfig) -> BreatheSymbolEffect {
+  let styled: BreatheSymbolEffect = switch config.style {
+  case .pulse: .breathe.pulse
+  case .plain: .breathe.plain
+  default: .breathe
+  }
+  return switch config.scope {
+  case .byLayer: styled.byLayer
+  case .wholeSymbol: styled.wholeSymbol
+  default: styled
+  }
+}
+
+@available(iOS 18.0, tvOS 18.0, *)
+private func buildRotateEffect(_ config: SymbolEffectConfig) -> RotateSymbolEffect {
+  let directed: RotateSymbolEffect = switch config.direction {
+  case .clockwise: .rotate.clockwise
+  case .counterClockwise: .rotate.counterClockwise
+  default: .rotate
+  }
+  return switch config.scope {
+  case .byLayer: directed.byLayer
+  case .wholeSymbol: directed.wholeSymbol
+  default: directed
+  }
+}
+
+@available(iOS 26.0, tvOS 26.0, *)
+private func buildDrawOnEffect(_ config: SymbolEffectConfig) -> DrawOnSymbolEffect {
+  return switch config.scope {
+  case .byLayer: .drawOn.byLayer
+  case .individually: .drawOn.individually
+  case .wholeSymbol: .drawOn.wholeSymbol
+  default: .drawOn
+  }
+}
+
+@available(iOS 26.0, tvOS 26.0, *)
+private func buildDrawOffEffect(_ config: SymbolEffectConfig) -> DrawOffSymbolEffect {
+  let played: DrawOffSymbolEffect = switch config.playbackStyle {
+  case .reversed: .drawOff.reversed
+  case .nonReversed: .drawOff.nonReversed
+  default: .drawOff
+  }
+  return switch config.scope {
+  case .byLayer: played.byLayer
+  case .individually: played.individually
+  case .wholeSymbol: played.wholeSymbol
+  default: played
+  }
+}
+
+// MARK: - Dispatch
+
+@available(iOS 17.0, tvOS 17.0, *)
+@ViewBuilder
+private func applyIndefiniteEffect<TargetView: View>(
+  to view: TargetView,
+  config: SymbolEffectConfig,
+  options: SymbolEffectOptions,
+  isActive: Bool
+) -> some View {
+  switch config.effect {
+  case .pulse:
+    view.symbolEffect(buildPulseEffect(config), options: options, isActive: isActive)
+  case .bounce:
+    view.symbolEffect(buildBounceEffect(config), options: options, isActive: isActive)
+  case .variableColor:
+    view.symbolEffect(buildVariableColorEffect(config), options: options, isActive: isActive)
+  case .scale:
+    view.symbolEffect(buildScaleEffect(config), options: options, isActive: isActive)
+  case .appear:
+    view.symbolEffect(buildAppearEffect(config), options: options, isActive: isActive)
+  case .disappear:
+    view.symbolEffect(buildDisappearEffect(config), options: options, isActive: isActive)
+  case .wiggle:
+    if #available(iOS 18.0, tvOS 18.0, *) {
+      view.symbolEffect(buildWiggleEffect(config), options: options, isActive: isActive)
+    } else {
+      view
+    }
+  case .breathe:
+    if #available(iOS 18.0, tvOS 18.0, *) {
+      view.symbolEffect(buildBreatheEffect(config), options: options, isActive: isActive)
+    } else {
+      view
+    }
+  case .rotate:
+    if #available(iOS 18.0, tvOS 18.0, *) {
+      view.symbolEffect(buildRotateEffect(config), options: options, isActive: isActive)
+    } else {
+      view
+    }
+  case .drawOn:
+    if #available(iOS 26.0, tvOS 26.0, *) {
+      view.symbolEffect(buildDrawOnEffect(config), options: options, isActive: isActive)
+    } else {
+      view
+    }
+  case .drawOff:
+    if #available(iOS 26.0, tvOS 26.0, *) {
+      view.symbolEffect(buildDrawOffEffect(config), options: options, isActive: isActive)
+    } else {
+      view
+    }
+  }
+}
+
+@available(iOS 17.0, tvOS 17.0, *)
+@ViewBuilder
+private func applyDiscreteEffect<TargetView: View>(
+  to view: TargetView,
+  config: SymbolEffectConfig,
+  options: SymbolEffectOptions,
+  value: AnyHashable
+) -> some View {
+  switch config.effect {
+  case .pulse:
+    view.symbolEffect(buildPulseEffect(config), options: options, value: value)
+  case .bounce:
+    view.symbolEffect(buildBounceEffect(config), options: options, value: value)
+  case .variableColor:
+    view.symbolEffect(buildVariableColorEffect(config), options: options, value: value)
+  case .wiggle:
+    if #available(iOS 18.0, tvOS 18.0, *) {
+      view.symbolEffect(buildWiggleEffect(config), options: options, value: value)
+    } else {
+      view
+    }
+  case .breathe:
+    if #available(iOS 18.0, tvOS 18.0, *) {
+      view.symbolEffect(buildBreatheEffect(config), options: options, value: value)
+    } else {
+      view
+    }
+  case .rotate:
+    if #available(iOS 18.0, tvOS 18.0, *) {
+      view.symbolEffect(buildRotateEffect(config), options: options, value: value)
+    } else {
+      view
+    }
+  // Scale, Appear, Disappear, DrawOn, DrawOff don't conform to
+  // DiscreteSymbolEffect — they no-op when bound to a `value`.
+  case .scale, .appear, .disappear, .drawOn, .drawOff:
+    view
+  }
+}
+
+// MARK: - Discrete wrapper
+
+@available(iOS 17.0, tvOS 17.0, *)
+private struct DiscreteEffectView<WrappedContent: View>: View {
+  let config: SymbolEffectConfig
+  let options: SymbolEffectOptions
+  @ObservedObject var state: ObservableState
+  @ViewBuilder let content: () -> WrappedContent
+
+  var body: some View {
+    let trigger = (state.value as? AnyHashable) ?? AnyHashable(0)
+    applyDiscreteEffect(to: content(), config: config, options: options, value: trigger)
+  }
+}
+
+// MARK: - Indefinite wrapper
+
+@available(iOS 17.0, tvOS 17.0, *)
+private struct IndefiniteEffectView<WrappedContent: View>: View {
+  let config: SymbolEffectConfig
+  let options: SymbolEffectOptions
+  @ObservedObject var state: ObservableState
+  @ViewBuilder let content: () -> WrappedContent
+
+  var body: some View {
+    let active = (state.value as? Bool) ?? true
+    applyIndefiniteEffect(to: content(), config: config, options: options, isActive: active)
+  }
+}

package/ios/Modifiers/ViewModifierRegistry.swift

@@ -621,38 +621,12 @@ internal struct AnyViewModifier: ViewModifier {
   }
 }
 
-internal enum AnimationType: String, Enumerable {
-  case easeInOut
-  case easeIn
-  case easeOut
-  case linear
-  case spring
-  case interpolatingSpring
-  case `default`
-}
-
-internal struct AnimationConfig: Record {
-  @Field var type: AnimationType = .default
-  @Field var duration: Double?
-  @Field var response: Double?
-  @Field var dampingFraction: Double?
-  @Field var blendDuration: Double?
-  @Field var bounce: Double?
-  @Field var mass: Double?
-  @Field var stiffness: Double?
-  @Field var damping: Double?
-  @Field var initialVelocity: Double?
-  @Field var delay: Double?
-  @Field var repeatCount: Int?
-  @Field var autoreverses: Bool?
-}
-
 internal struct AnimationModifier: ViewModifier, Record {
   @Field var animation: AnimationConfig
   @Field var animatedValue: Either<Double, Bool>?
 
   func body(content: Content) -> some View {
-    let animationValue = parseAnimation(animation)
+    let animationValue = animation.toSwiftUIAnimation()
     if let value: Bool = animatedValue?.get() {
       content.animation(animationValue, value: value)
     } else if let value: Double = animatedValue?.get() {
@@ -661,91 +635,6 @@ internal struct AnimationModifier: ViewModifier, Record {
       content
     }
   }
-
-  private func parseAnimation(_ config: AnimationConfig) -> Animation {
-    let type = config.type
-
-    var animation: Animation
-
-    switch type {
-    case .easeIn:
-      if let duration = config.duration {
-        animation = .easeIn(duration: duration)
-      } else {
-        animation = .easeIn
-      }
-
-    case .easeOut:
-      if let duration = config.duration {
-        animation = .easeOut(duration: duration)
-      } else {
-        animation = .easeOut
-      }
-
-    case .linear:
-      if let duration = config.duration {
-        animation = .linear(duration: duration)
-      } else {
-        animation = .linear
-      }
-
-    case .easeInOut:
-      if let duration = config.duration {
-        animation = .easeInOut(duration: duration)
-      } else {
-        animation = .easeInOut
-      }
-
-    case .spring:
-      let duration = config.duration
-      let bounce = config.bounce
-      let response = config.response
-      let dampingFraction = config.dampingFraction
-      let blendDuration = config.blendDuration
-
-      if response != nil || dampingFraction != nil {
-        // default values are 0.5, 0.825, 0.0
-        animation = .spring(response: response ?? 0.5, dampingFraction: dampingFraction ?? 0.825, blendDuration: blendDuration ?? 0.0)
-      } else if duration != nil || bounce != nil {
-        // default values are 0.5, 0.0, 0.0
-        animation = .spring(duration: duration ?? 0.5, bounce: bounce ?? 0.0, blendDuration: blendDuration ?? 0.0)
-      } else if let blendDuration = blendDuration {
-        animation = .spring(blendDuration: blendDuration)
-      } else {
-        animation = .spring
-      }
-
-    case .interpolatingSpring:
-      let duration = config.duration
-      let bounce = config.bounce
-      let mass = config.mass
-      let stiffness = config.stiffness
-      let damping = config.damping
-      let initialVelocity = config.initialVelocity
-
-      if duration != nil || bounce != nil {
-        animation = .interpolatingSpring(duration: duration ?? 0.5, bounce: bounce ?? 0.0, initialVelocity: initialVelocity ?? 0.0)
-      } else if let stiffness, let damping {
-        animation = .interpolatingSpring(mass: mass ?? 1.0, stiffness: stiffness, damping: damping, initialVelocity: initialVelocity ?? 0.0)
-      } else {
-        animation = .interpolatingSpring
-      }
-
-    default:
-      animation = .default
-    }
-
-    if let delay = config.delay {
-      animation = animation.delay(delay)
-    }
-
-    if let repeatCount = config.repeatCount {
-      let autoreverses = config.autoreverses ?? false
-      animation = animation.repeatCount(repeatCount, autoreverses: autoreverses)
-    }
-
-    return animation
-  }
 }
 
 internal enum ScrollContentBackgroundTypes: String, Enumerable {
@@ -1957,5 +1846,9 @@ extension ViewModifierRegistry {
     register("containerBackground") { params, appContext, _ in
       return try ContainerBackgroundModifier(from: params, appContext: appContext)
     }
+
+    register("symbolEffect") { params, appContext, _ in
+      return try SymbolEffectModifier(from: params, appContext: appContext)
+    }
   }
 }

package/ios/SlotView.swift

@@ -5,6 +5,7 @@ import ExpoModulesCore
 
 internal final class SlotViewProps: ExpoSwiftUI.ViewProps {
   @Field var name: String = ""
+  @Field var extraProps: [String: Any]?
 }
 
 internal struct SlotView: ExpoSwiftUI.View {
@@ -17,6 +18,10 @@ internal struct SlotView: ExpoSwiftUI.View {
   var body: some View {
     Children()
   }
+
+  func extra<T>(_ key: String, as type: T.Type = T.self) -> T? {
+    return props.extraProps?[key] as? T
+  }
 }
 
 extension [any ExpoSwiftUI.AnyChild] {