Confirm Sheet

// Copyright (c) 2026 Saivion Hayes
//
// 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, and distribute the Software as part of
// an application, website, or product, 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.
//
// Commons Clause Restriction
//
// You may use this Software, including for any commercial purpose, so long as
// you do not sell, sublicense, or redistribute the components themselves, whether
// alone, in a bundle, or as a ported version.
//
// 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.

import SwiftUI

/// Presents a confirmation card as a bottom sheet, or inline as an overlay in the current hierarchy.
///
/// - Parameters:
///   - isPresented: Shows the card while `true`. Confirming, cancelling, and dragging away set it back to `false`.
///   - inline: `true` overlays the card in place with a dimmed backdrop and a rubber-banded drag to dismiss; `false` uses `.sheet` sized to the card.
///   - systemImage: SF Symbol in the icon tile.
///   - title: Headline.
///   - message: Supporting copy under the title.
///   - confirmTitle: Primary button title.
///   - cancelTitle: Secondary button title, on a neutral glass capsule that buds out of the primary as the card lands.
///   - isDestructive: Uses the destructive tile and the signal-tinted primary button, and plays a `.warning` haptic on present.
///   - style: Colors and corner radius. Defaults to the SwiftPieces house palette, adapting to light and dark.
///   - confirm: Async handler for the primary button. Cancel melts back into the button, which spins and reads Working until it returns, then turns sage with a check and Done that the tile answers a beat later, then the card dismisses.
public extension View {
    func confirmSheet(isPresented: Binding<Bool>, inline: Bool = false, systemImage: String, title: String, message: String, confirmTitle: String = "Confirm", cancelTitle: String = "Cancel", isDestructive: Bool = false, style: ConfirmSheet.Style = .standard, confirm: @escaping () async -> Void) -> some View {
        modifier(ConfirmSheet.Presenter(isPresented: isPresented, inline: inline, style: style, card: ConfirmSheet(isPresented: isPresented, systemImage: systemImage, title: title, message: message, confirmTitle: confirmTitle, cancelTitle: cancelTitle, isDestructive: isDestructive, style: style, confirm: confirm)))
    }
}

/// The card itself. Use the `.confirmSheet` modifier to present it; embed it directly only for custom containers.
public struct ConfirmSheet: View {
    /// Colors and shape. `.standard` is the house palette.
    public struct Style: Sendable {
        /// The card.
        public var surface: Color
        /// Headline, and the glass tint of the non-destructive primary button.
        public var label: Color
        /// Message text.
        public var secondaryLabel: Color
        /// Text on the non-destructive primary button.
        public var onLabel: Color
        /// The grabber. Since the liquid glass refactor the cancel button is neutral glass, so this no longer colors it.
        public var quiet: Color
        /// Glyphs and text on solid blocks and tinted glass.
        public var ink: Color
        /// Icon tile for non-destructive cards.
        public var tile: Color
        /// Icon tile for destructive cards.
        public var destructiveTile: Color
        /// The glass tint of the primary button on destructive cards.
        public var destructive: Color
        /// The tile, and the primary button's glass tint, once `confirm` has finished.
        public var success: Color
        /// Card corner radius.
        public var cornerRadius: CGFloat

        /// Pass only what you want to change; `nil` keeps the house palette value.
        public init(surface: Color? = nil, label: Color? = nil, secondaryLabel: Color? = nil, onLabel: Color? = nil, quiet: Color? = nil, ink: Color? = nil, tile: Color? = nil, destructiveTile: Color? = nil, destructive: Color? = nil, success: Color? = nil, cornerRadius: CGFloat = 34) {
            self.surface = surface ?? adaptive(light: 0xFFFFFF, dark: 0x1C1C1C)
            self.label = label ?? adaptive(light: 0x141414, dark: 0xF4F3EF)
            self.secondaryLabel = secondaryLabel ?? adaptive(light: 0x5C5A56, dark: 0xA6A49F)
            self.onLabel = onLabel ?? adaptive(light: 0xF4F3EF, dark: 0x141414)
            self.quiet = quiet ?? adaptive(light: 0xEEECE7, dark: 0x2A2A2A)
            self.ink = ink ?? adaptive(light: 0x141414, dark: 0x141414)
            self.tile = tile ?? adaptive(light: 0x9CC2FF, dark: 0x9CC2FF)
            self.destructiveTile = destructiveTile ?? adaptive(light: 0xFF0000, dark: 0xFF0000)
            self.destructive = destructive ?? adaptive(light: 0xFF0000, dark: 0xFF0000)
            self.success = success ?? adaptive(light: 0xA9DCB7, dark: 0xA9DCB7)
            self.cornerRadius = cornerRadius
        }

        public static let standard = Style()
    }

    private enum Phase { case presenting, idle, confirming, done, dismissing }

    @Environment(\.accessibilityReduceMotion) private var reduceMotion
    @ScaledMetric(relativeTo: .title) private var titleSize: CGFloat = 26
    @Binding private var isPresented: Bool
    @State private var phase: Phase = .presenting
    @State private var presentTick = 0
    @State private var tileDone = false  // only ever turns on: a beat after the button's check
    @State private var warned = false    // only ever turns on: the destructive warning, once per presentation
    /// The cancel bubble: home inside confirm until the card lands, out below it while the choice is open.
    @State private var buds = PieceBuds()
    @State private var cancelHeight: CGFloat = 56

    private let systemImage: String
    private let title: String
    private let message: String
    private let confirmTitle: String
    private let cancelTitle: String
    private let isDestructive: Bool
    private let style: Style
    private let confirm: () async -> Void

    public init(isPresented: Binding<Bool>, systemImage: String, title: String, message: String, confirmTitle: String = "Confirm", cancelTitle: String = "Cancel", isDestructive: Bool = false, style: Style = .standard, confirm: @escaping () async -> Void) {
        self._isPresented = isPresented
        self.systemImage = systemImage
        self.title = title
        self.message = message
        self.confirmTitle = confirmTitle
        self.cancelTitle = cancelTitle
        self.isDestructive = isDestructive
        self.style = style
        self.confirm = confirm
    }

    private var busy: Bool { phase == .confirming || phase == .done }
    /// The primary's glass: signal on a destructive card, the label color on any other, sage once it is done.
    private var primaryTint: Color { phase == .done ? style.success : (isDestructive ? style.destructive : style.label) }
    private var primaryText: Color { phase == .done || isDestructive ? style.ink : style.onLabel }
    private var primaryTitle: String {
        switch phase {
        case .confirming: String(localized: "Working", comment: "Confirm sheet primary button while the confirmed action runs")
        case .done: String(localized: "Done", comment: "Confirm sheet primary button once the confirmed action has finished")
        default: confirmTitle
        }
    }

    public var body: some View {
        let motion = PieceMotion(reduceMotion: reduceMotion)
        VStack(alignment: .leading, spacing: 0) {
            Capsule()
                .fill(style.quiet)
                .frame(width: 36, height: 5)
                .frame(maxWidth: .infinity)
                .padding(.bottom, 18)
                .accessibilityHidden(true)

            // The tile answers the button: it turns into a sage check a beat after the button's own check, and pops.
            Image(systemName: tileDone ? "checkmark" : systemImage)
                .font(.system(size: 24, weight: .semibold))
                .foregroundStyle(style.ink)
                .contentTransition(reduceMotion ? .opacity : .symbolEffect(.replace))
                .symbolEffect(.bounce.down, options: reduceMotion ? .speed(100) : .default, value: presentTick)
                .frame(width: 60, height: 60)
                .background(tileDone ? style.success : (isDestructive ? style.destructiveTile : style.tile), in: .rect(cornerRadius: 18, style: .continuous))
                .animation(motion.morph, value: tileDone)
                .piecePop(trigger: tileDone)
                .accessibilityHidden(true)

            Text(title)
                .font(.system(size: titleSize, weight: .semibold))
                .tracking(-0.6)
                .foregroundStyle(style.label)
                .fixedSize(horizontal: false, vertical: true)
                .padding(.top, 20)
            Text(message)
                .font(.body.weight(.semibold))
                .foregroundStyle(style.secondaryLabel)
                .fixedSize(horizontal: false, vertical: true)
                .padding(.top, 6)

            // Two separate actions, so they rest apart: each its own glass capsule, gooey only while cancel buds out of
            // confirm or melts back into it.
            PieceLiquidGroup {
                VStack(spacing: PieceLiquid.apart) {
                    // Above cancel, so cancel at home sits under it and melts in rather than over its label.
                    primaryButton.zIndex(1)
                    cancelSlot
                }
            }
            .padding(.top, 24)
            // The tint, the glyph and the label all change with the phase.
            .animation(motion.snap, value: phase)
        }
        .padding(.horizontal, 20)
        .padding(.top, 10)
        .padding(.bottom, 20)
        .frame(maxWidth: .infinity)
        .fontWeight(.semibold)
        // The card resolves its geometry as one piece, so its glass leaves with it when the inline card slides away.
        // Without it the budded cancel capsule's glass was left behind for a moment on iOS 26.
        .geometryGroup()
        .sensoryFeedback(.warning, trigger: warned) { _, new in new }
        .sensoryFeedback(.success, trigger: phase) { _, new in new == .done }
        .onAppear { phase = .idle }
        // The tile's bounce, the split and the destructive warning wait for the card to land, so they aren't spent
        // mid-slide. A confirm before then has already played the warning, and leaves cancel inside confirm; after a
        // cancel a warning would contradict the person.
        .task {
            try? await Task.sleep(for: .milliseconds(reduceMotion ? 200 : 300))
            guard !Task.isCancelled, isPresented, phase == .idle else { return }
            presentTick += 1
            warn()
            await buds.bloom(["cancel"], reduceMotion: reduceMotion)
        }
        .accessibilityAddTraits(.isModal)
    }

    /// The primary action on a capsule of glass. While `confirm` runs a spinner sharpens in beside a label that morphs to
    /// Working; when it returns the spinner gives way to a check, the label morphs to Done and the glass turns sage.
    private var primaryButton: some View {
        let motion = PieceMotion(reduceMotion: reduceMotion)
        return Button(role: isDestructive ? .destructive : nil) {
            guard phase == .idle || phase == .presenting else { return }
            warn()  // a confirm before the card lands still gets its warning, on the tap
            phase = .confirming
            // The choice is made, so cancel melts back into the button that made it.
            if buds.contains("cancel") {
                Task { await buds.gather(["cancel"], reduceMotion: reduceMotion) }
            }
            Task {
                await confirm()
                // The check lands on the button first, under the finger, with the success haptic, and the tile
                // answers a beat later. The beat as a whole is unchanged. The phase stays `.done`, so the card
                // leaves showing its outcome.
                phase = .done
                try? await Task.sleep(for: .milliseconds(80))
                tileDone = true
                try? await Task.sleep(for: .milliseconds(reduceMotion ? 170 : 470))
                isPresented = false
            }
        } label: {
            ZStack {
                // Holds the height at any text size, so the swap never resizes the card or a sheet's detent.
                Text(confirmTitle).hidden()
                HStack(spacing: 8) {
                    switch phase {
                    case .confirming: ProgressView().tint(primaryText).transition(motion.swap)
                    case .done: Image(systemName: "checkmark").transition(motion.swap)
                    default: EmptyView()
                    }
                    ConfirmSheetLabel(text: primaryTitle, font: .headline.weight(.semibold))
                }
            }
            .font(.headline.weight(.semibold))
            .foregroundStyle(primaryText)
            .padding(.horizontal, 20)
            .frame(maxWidth: .infinity, minHeight: 56)
            .contentShape(.capsule)
            .pieceLiquid(.capsule, tint: primaryTint, interactive: false)
        }
        .buttonStyle(PieceLiquidPressStyle())
        .disabled(busy)
        .accessibilityLabel(primaryTitle)
    }

    /// Cancel's place under the primary. It keeps its size while cancel is inside the primary, so the card and a sheet's
    /// detent never change height.
    private var cancelSlot: some View {
        cancelLabel(out: true)
            .hidden()
            .onGeometryChange(for: CGFloat.self) { $0.size.height } action: { cancelHeight = $0 }
            .overlay {
                if buds.contains("cancel") { cancelButton }
            }
    }

    private func cancelLabel(out: Bool) -> some View {
        Text(cancelTitle)
            .font(.headline.weight(.semibold))
            .foregroundStyle(style.label)
            .pieceBudContent(out: out)
            .padding(.horizontal, 20)
            .frame(maxWidth: .infinity, minHeight: 56)
    }

    /// A neutral glass capsule. Home is just inside the primary's lower end, shrunk, where the two are one shape, so it
    /// buds down out of the primary as the card lands and melts back up into it once the choice is made.
    private var cancelButton: some View {
        let out = buds.isOut("cancel")
        return Button {
            guard !busy else { return }
            phase = .dismissing
            isPresented = false
        } label: {
            cancelLabel(out: out)
                .contentShape(.capsule)
                .pieceLiquid(.capsule, interactive: false)
        }
        .buttonStyle(PieceLiquidPressStyle())
        .disabled(busy)
        .pieceBud(out: out, home: CGSize(width: 0, height: -(cancelHeight / 2 + PieceLiquid.apart + cancelHeight * PieceLiquid.homeScale / 2)))
    }

    /// The destructive warning, at most once per presentation.
    private func warn() {
        guard isDestructive, !warned else { return }
        warned = true
    }

    /// Chooses `.sheet` or an inline overlay for the card.
    struct Presenter: ViewModifier {
        @Environment(\.accessibilityReduceMotion) private var reduceMotion
        @Binding var isPresented: Bool
        let inline: Bool
        let style: Style
        let card: ConfirmSheet
        @State private var cardHeight: CGFloat = 320
        @State private var dragOffset: CGFloat = 0
        @State private var pastThreshold = false
        @State private var grabShift: CGFloat?         // the card's pull less the finger's translation; nil between drags
        @State private var homing: Homing?             // the last return home, so a grab can catch the card partway
        @State private var flick: CGFloat = 0          // the card's speed when a drag commits, carried into the exit
        @GestureState private var dragging = false     // resets when the system cancels a touch, which skips onEnded

        /// Past the card's own height, which the move covers: the home indicator and the shadow's reach, so the card
        /// starts and ends fully out of sight and never needs to fade.
        private static let clearance: CGFloat = 64
        /// The rubber band upward, shared by `offset(for:)` and its inverse.
        private static let band = (limit: CGFloat(60), coefficient: CGFloat(0.55))

        /// A return home in flight, so a grab can pick the card up where it is rather than where it is headed.
        private struct Homing {
            var from: CGFloat
            var speed: CGFloat
            var spring: Spring
            var reach: Double  // settle's speed cap, in spring frequencies
            var at: Date

            /// The card's offset at `time` on the curve `settle(velocity:from:to:spring:)` drew, with its speed cap.
            func offset(at time: Date) -> CGFloat {
                let elapsed = time.timeIntervalSince(at)
                guard abs(from) >= 1, elapsed < spring.settlingDuration else { return 0 }
                let cap = 2 * Double.pi / spring.duration * reach
                let relative = CGFloat(min(max(Double(speed / -from), -cap), cap))
                return from + spring.value(target: -from, initialVelocity: relative * -from, time: elapsed)
            }
        }

        func body(content: Content) -> some View {
            if inline {
                let motion = PieceMotion(reduceMotion: reduceMotion)
                content.overlay {
                    ZStack(alignment: .bottom) {
                        if isPresented {
                            // The tray brightens as the card is pulled away from it.
                            Color.black.opacity(0.35 * scrim)
                                .ignoresSafeArea()
                                .onTapGesture { isPresented = false }
                                .transition(.opacity)
                                .accessibilityHidden(true)
                            measured
                                .background(style.surface, in: .rect(cornerRadius: style.cornerRadius, style: .continuous))
                                .shadow(color: .black.opacity(0.22), radius: 34, y: 14)
                                .padding(.horizontal, 10)
                                .padding(.bottom, 10)
                                .offset(y: dragOffset)
                                .gesture(drag)
                                // Without it SwiftUI draws the leaving card under the leaving scrim, so it turns gray as it goes.
                                .zIndex(1)
                                .transition(motion.transition(.move(edge: .bottom).combined(with: .offset(y: Self.clearance))))
                                .onAppear {
                                    dragOffset = 0
                                    flick = 0
                                    grabShift = nil
                                    homing = nil
                                    pastThreshold = false
                                }
                                // A drag the system cancelled (a call, an alert) never ran onEnded, so bring the card home
                                // here. After a normal release onEnded has already sent it home or away.
                                .onChange(of: dragging) { _, isDragging in
                                    if !isDragging, grabShift != nil { letGo(speed: 0) }
                                }
                        }
                    }
                    // Scoped to the tray and card. It arrives calmly and leaves quicker, at the card's speed after a drag.
                    .animation(isPresented ? motion.reveal : exitAnimation(motion), value: isPresented)
                }
                .sensoryFeedback(.impact(flexibility: .rigid), trigger: pastThreshold) { _, past in past }
            } else {
                content.sheet(isPresented: $isPresented) {
                    measured
                        .presentationDetents([.height(cardHeight)])
                        .presentationCornerRadius(style.cornerRadius)
                        .presentationDragIndicator(.hidden)
                        .presentationBackground(style.surface)
                }
            }
        }

        private var measured: some View {
            card.background {
                GeometryReader { proxy in
                    Color.clear
                        .onAppear { cardHeight = proxy.size.height }
                        .onChange(of: proxy.size.height) { _, height in cardHeight = height }
                }
            }
        }

        /// 1 at rest, thinning to 0 as the card is pulled down by its own height.
        private var scrim: Double {
            Double(1 - min(max(dragOffset / max(cardHeight, 1), 0), 1))
        }

        /// The way out. A drag that commits leaves at the card's own speed; a button, the backdrop and the host use the
        /// plain dismiss.
        private func exitAnimation(_ motion: PieceMotion) -> Animation {
            guard !reduceMotion, flick > 0 else { return motion.dismiss }
            // Firm like the dismiss role, with no overshoot at all, started at the flick's speed over the distance the
            // exit transition covers.
            return motion.settle(velocity: flick, from: 0, to: cardHeight + 10 + Self.clearance, spring: Spring(duration: 0.28, bounce: 0))
        }

        /// The card's offset for a vertical drag of `t`: 1:1 downward, rubber-banded upward against its tether.
        private func offset(for t: CGFloat) -> CGFloat {
            PieceMotion.rubberBand(t, in: 0...CGFloat.infinity, limit: Self.band.limit, coefficient: Self.band.coefficient)
        }

        /// The pull that puts the card at `offset`, the inverse of `offset(for:)`, so a grab can take hold anywhere.
        private func translation(for offset: CGFloat) -> CGFloat {
            guard offset < 0 else { return offset }
            let share = min(-offset / Self.band.limit, 0.95)
            return -share / (1 - share) * Self.band.limit / Self.band.coefficient
        }

        /// Downward the card stays under the finger, upward it gives with rubber-band resistance; a flick past the
        /// threshold commits.
        private var drag: some Gesture {
            DragGesture(minimumDistance: 6)
                .updating($dragging) { _, state, _ in state = true }
                .onChanged { value in
                    let t = value.translation.height
                    // The drag takes hold wherever the card is, at rest or partway home from a release, so it never
                    // jumps to meet the finger, not even by the 6pt the gesture waits for. The direct write also stops
                    // a return in flight right there. From then on the card moves with the finger, unanimated.
                    let shift = grabShift ?? translation(for: homing?.offset(at: .now) ?? 0) - t
                    if grabShift == nil {
                        grabShift = shift
                        homing = nil
                    }
                    dragOffset = offset(for: t + shift)
                    // On at the commit line, off only well short of it, so a trembling finger can't repeat the tick.
                    let predicted = value.predictedEndTranslation.height
                    pastThreshold = pastThreshold ? predicted > 60 : predicted > 90
                }
                .onEnded { value in
                    let t = value.translation.height
                    let pull = t + (grabShift ?? 0)
                    // The card's own speed, not the finger's: pulled upward, the band slows it.
                    let speed = (offset(for: pull + value.velocity.height * 0.01) - offset(for: pull)) / 0.01
                    if value.predictedEndTranslation.height > 90 || t > cardHeight * 0.4 {
                        // Only speed toward the exit carries over, so a finger already easing back never lifts the card first.
                        flick = max(speed, 0)
                        grabShift = nil
                        pastThreshold = false
                        isPresented = false
                    } else {
                        letGo(speed: speed)
                    }
                }
        }

        /// The card comes home leaving at `speed` (pt/s). From below it lands on the snap tier with only a small give,
        /// as a weighted card would; pulled up against the tether, it rebounds with more.
        private func letGo(speed: CGFloat) {
            let motion = PieceMotion(reduceMotion: reduceMotion)
            let spring = dragOffset < 0 ? PieceMotion.elastic : PieceMotion.responsive
            // Under Reduce Motion `settle` swaps in its short spring and a lower speed cap, so it can't overshoot; the
            // record follows both, or a quick re-grab would jump to where the card isn't.
            homing = Homing(from: dragOffset, speed: speed, spring: reduceMotion ? Spring(duration: 0.25, bounce: 0) : spring, reach: reduceMotion ? 1 : 1.5, at: .now)
            withAnimation(motion.settle(velocity: speed, from: dragOffset, to: 0, spring: spring)) { dragOffset = 0 }
            grabShift = nil
            pastThreshold = false
        }
    }
}

/// A label that morphs letter by letter when it changes. At accessibility text sizes it is plain text that can wrap,
/// and blurs from the old words to the new instead.
private struct ConfirmSheetLabel: View {
    let text: String
    let font: Font
    @Environment(\.dynamicTypeSize) private var typeSize
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    var body: some View {
        if typeSize.isAccessibilitySize {
            Text(text)
                .font(font)
                .multilineTextAlignment(.center)
                .id(text)
                .transition(PieceMotion(reduceMotion: reduceMotion).swap)
        } else {
            PieceMorphText(text: text, font: font)
        }
    }
}

/// A house-palette color that follows the interface style.
private func adaptive(light: UInt32, dark: UInt32) -> Color {
    Color(uiColor: UIColor { @Sendable traits in
        let hex = traits.userInterfaceStyle == .dark ? dark : light
        return UIColor(red: CGFloat((hex >> 16) & 0xFF) / 255, green: CGFloat((hex >> 8) & 0xFF) / 255, blue: CGFloat(hex & 0xFF) / 255, alpha: 1)
    })
}

// MARK: - Example

/// The card alone, inline, over its own dimmed backdrop. Tap the ground to bring it back once it has gone.
private struct ConfirmSheetExample: View {
    @State private var confirming = true

    var body: some View {
        Color.clear
            .frame(maxWidth: .infinity, maxHeight: .infinity)
            .background(adaptive(light: 0xF3F2EE, dark: 0x121212))
            .contentShape(.rect)
            .onTapGesture { confirming = true }
            .confirmSheet(isPresented: $confirming, inline: true, systemImage: "trash", title: "Delete this note?", message: "It will be removed from your iPhone, iPad and Mac. This can't be undone.", confirmTitle: "Delete note", isDestructive: true) {
                try? await Task.sleep(for: .seconds(0.8))
            }
    }
}

#Preview("Light") {
    ConfirmSheetExample()
}

#Preview("Dark") {
    ConfirmSheetExample()
        .preferredColorScheme(.dark)
}

// MARK: - Piece motion
//
// The SwiftPieces motion language: shared spring tokens and gesture physics, with the same values in every
// piece. Each piece carries a copy of only the parts it uses, so this file stands alone. Generated from
// registry/foundation/PieceMotion.swift in the SwiftPieces repo; edit it there, not here.
// swiftpieces-motion: 1.1.0 (core, momentum, rubberBand, pressMath, pop)

/// The SwiftPieces motion language: five spring tiers, and a named role for every moment a piece moves,
/// each with its Reduce Motion substitute.
///
/// Build one from the environment, `PieceMotion(reduceMotion: reduceMotion)`, and pick the role that names
/// what just happened. Never animate the tracking of a finger: set gesture state directly in `onChanged`, so the
/// surface stays under the finger, and spring only the release.
private struct PieceMotion {
    var reduceMotion = false

    // Tiers. Overshoot and settle times are measured from rest with SwiftUI's Spring.
    /// No overshoot, 90% in about 90ms. A press arriving under the finger.
    static var tight: Spring { Spring(duration: 0.14, bounce: 0) }
    /// About 2.8% overshoot, 90% in about 140ms. Snapping to a detent, page or segment.
    static var responsive: Spring { Spring(duration: 0.32, bounce: 0.25) }
    /// About 8.4% overshoot. Visible give: a release, a return from past an edge, a drag settling home.
    static var elastic: Spring { Spring(duration: 0.42, bounce: 0.38) }
    /// About 15% overshoot. A resolved action landing. At most once per interaction.
    static var expressive: Spring { Spring(duration: 0.48, bounce: 0.48) }
    /// About 1.5% overshoot, unhurried. Opening large surfaces and ambient change.
    static var calm: Spring { Spring(duration: 0.5, bounce: 0.2) }

    /// Reduce Motion: settles become this short spring with no overshoot.
    private static var still: Animation { .spring(duration: 0.25, bounce: 0) }

    // Roles.
    /// Touch-down. Starts on the same frame and never bounces under the finger.
    var press: Animation { .spring(Self.tight) }
    /// The finger lifts off a pressed surface, which springs back through rest.
    var release: Animation { reduceMotion ? Self.still : .spring(Self.elastic) }
    /// A dragged thing comes to rest. With a gesture's velocity, use `settle(velocity:from:to:)` instead.
    var settle: Animation { reduceMotion ? Self.still : .spring(Self.elastic) }
    /// Lands on a detent, page or segment.
    var snap: Animation { reduceMotion ? Self.still : .spring(Self.responsive) }
    /// A number, a chart value or anything else people read moves to its new value. Never overshoots, so it
    /// never shows a value that isn't true.
    var value: Animation { reduceMotion ? Self.still : .spring(duration: 0.35, bounce: 0) }
    /// Comes back from past a limit: a pull beyond the edge, a value pushed against its bound.
    var rebound: Animation { reduceMotion ? Self.still : .spring(Self.elastic) }
    /// A shape or container changes size, corner radius or form, with a little give at the end.
    var morph: Animation { reduceMotion ? Self.still : .spring(duration: 0.4, bounce: 0.2) }
    /// Something appears, opens or expands. Opening is a little slower than closing.
    var reveal: Animation { reduceMotion ? .easeOut(duration: 0.2) : .spring(Self.calm) }
    /// Something leaves, closes or collapses. Quick and firm, out of the way.
    var dismiss: Animation { reduceMotion ? .easeIn(duration: 0.18) : .spring(duration: 0.3, bounce: 0.08) }
    /// A resolved action lands: a check, a sent state, a reaction.
    var success: Animation { reduceMotion ? .easeOut(duration: 0.24) : .spring(Self.expressive) }
    /// A refused action. Firm, no wobble; `pieceShake` adds the movement.
    var error: Animation { reduceMotion ? .easeOut(duration: 0.2) : .spring(Self.responsive) }
    /// Slow ambient change. Loops themselves stop under Reduce Motion: check `allowsAmbient`.
    var ambient: Animation { reduceMotion ? .easeInOut(duration: 0.3) : .spring(Self.calm) }

    /// Loops, drifts, idle breathing and parallax run only when this is true.
    var allowsAmbient: Bool { !reduceMotion }

    /// A moving transition, or a plain fade under Reduce Motion.
    func transition(_ transition: AnyTransition) -> AnyTransition {
        reduceMotion ? .opacity : transition
    }

    /// For content replaced inside a container that stays put (a label, a glyph, a count): the old content
    /// blurs out as the new one sharpens in. A fade under Reduce Motion.
    @MainActor var swap: AnyTransition {
        reduceMotion ? .opacity : AnyTransition(.blurReplace)
    }
}

extension PieceMotion {
    /// Where a flick at `velocity` (pt/s) coasts to. 0.998 coasts like a scroll view; 0.99 suits detents.
    nonisolated static func project(_ position: CGFloat, velocity: CGFloat, decelerationRate: CGFloat = 0.99) -> CGFloat {
        position + velocity / 1000 * decelerationRate / (1 - decelerationRate)
    }

    /// The candidate closest to `value`.
    nonisolated static func nearest(_ value: CGFloat, in candidates: [CGFloat]) -> CGFloat {
        candidates.min { abs($0 - value) < abs($1 - value) } ?? value
    }

    /// A settle that leaves at the finger's speed (pt/s). One per axis, each on its own `.offset(x:)` / `.offset(y:)`:
    /// a spring takes one velocity. SwiftUI's own velocity carry-over is unreliable; this always carries it.
    func settle(velocity: CGFloat, from current: CGFloat, to target: CGFloat, spring: Spring = PieceMotion.elastic) -> Animation {
        let spring = reduceMotion ? Spring(duration: 0.25, bounce: 0) : spring
        let distance = target - current
        guard abs(distance) >= 1 else { return .spring(spring) }
        // In whole distances per second, capped near the spring's frequency: a hard flick adds give, not a slingshot.
        // At exactly the frequency a critically damped spring cannot pass its target, so Reduce Motion stops there.
        let cap = 2 * Double.pi / spring.duration * (reduceMotion ? 1 : 1.5)
        let relative = min(max(Double(velocity / distance), -cap), cap)
        return .interpolatingSpring(spring, initialVelocity: relative)
    }
}

extension PieceMotion {
    /// A scroll view's edge resistance for a pull `overshoot` points past a limit; never reaches `limit`.
    /// About 24 to 40 for thumbs and toggles, 60 to 120 for cards and sheets. Band the total pull, not deltas.
    nonisolated static func rubberBand(_ overshoot: CGFloat, limit: CGFloat, coefficient: CGFloat = 0.55) -> CGFloat {
        guard limit > 0, overshoot != 0 else { return 0 }
        let banded = (1 - 1 / (abs(overshoot) * coefficient / limit + 1)) * limit
        return overshoot < 0 ? -banded : banded
    }

    /// `value` inside `range` passes through unchanged; past either end it moves with rubber-band resistance.
    nonisolated static func rubberBand(_ value: CGFloat, in range: ClosedRange<CGFloat>, limit: CGFloat, coefficient: CGFloat = 0.55) -> CGFloat {
        if value < range.lowerBound { return range.lowerBound + rubberBand(value - range.lowerBound, limit: limit, coefficient: coefficient) }
        if value > range.upperBound { return range.upperBound + rubberBand(value - range.upperBound, limit: limit, coefficient: coefficient) }
        return value
    }
}

extension PieceMotion {
    /// About `depth` points per edge, not a fixed percentage: an icon sinks to 0.92, a pill 0.95, a card 0.985.
    nonisolated static func pressScale(for size: CGSize, depth: CGFloat = 2.5) -> CGFloat {
        let side = (max(size.width, 1) * max(size.height, 1)).squareRoot()
        return min(max(1 - depth * 2 / side, 0.92), 0.985)
    }

    /// An anchor partway from the center toward the touch, so the press leans into the finger without tipping.
    nonisolated static func pressAnchor(touch: CGPoint?, in size: CGSize, lean: CGFloat = 0.6) -> UnitPoint {
        guard let touch, size.width > 0, size.height > 0 else { return .center }
        let x = min(max(touch.x / size.width, 0), 1)
        let y = min(max(touch.y / size.height, 0), 1)
        return UnitPoint(x: 0.5 + (x - 0.5) * lean, y: 0.5 + (y - 0.5) * lean)
    }
}

/// Anticipation, overshoot, settle: dips, swells past full size and lands each time `trigger` changes. Under
/// Reduce Motion it stays still (same view, no identity change) and the color or symbol carries the meaning.
private struct PiecePop: ViewModifier {
    let trigger: AnyHashable
    var amount: CGFloat = 0.08
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    func body(content: Content) -> some View {
        let amount = reduceMotion ? 0 : amount
        content.keyframeAnimator(initialValue: CGFloat(1), trigger: trigger) { view, scale in
            view.scaleEffect(scale)
        } keyframes: { _ in
            KeyframeTrack {
                CubicKeyframe(1 - amount * 0.4, duration: 0.08)
                SpringKeyframe(1 + amount, duration: 0.14, spring: Spring(duration: 0.18, bounce: 0))
                SpringKeyframe(1, duration: 0.42, spring: PieceMotion.expressive)
            }
        }
    }
}

private extension View {
    /// Pops each time `trigger` changes. Use a counter, never a Bool that can flip back before it fires.
    func piecePop(trigger: some Hashable & Sendable, amount: CGFloat = 0.08) -> some View {
        modifier(PiecePop(trigger: AnyHashable(trigger), amount: amount))
    }
}

// swiftpieces-motion: end

// MARK: - Piece liquid
//
// The SwiftPieces liquid glass language: glass shapes that merge through a neck, bubbles that bud out of
// and melt back into each other, and the frosted fallback before iOS 26. Each piece carries a copy of only
// the parts it uses, so this file stands alone. Generated from registry/foundation/PieceLiquid.swift in the
// SwiftPieces repo; edit it there, not here. The rules are in LIQUID_GLASS.md.
// swiftpieces-liquid: 1.8.0 (liquid, liquidPress, bud, morphText)

/// The liquid glass language: one merge distance, two rest gaps, and the springs a bubble leaves and comes home on.
///
/// Glass shapes inside one `PieceLiquidGroup` melt into each other through a neck when they come within `merge`
/// points. Parts of one control rest `joined`, inside that distance, so the neck holds; separate actions rest
/// `apart`, outside it, so they only goo while one buds out of, or melts back into, another.
private enum PieceLiquid {
    /// Glass shapes closer than this share a neck.
    static let merge: CGFloat = 20
    /// The gap between parts of one control (a stepper's buttons, a progress pill and its stop): the neck holds,
    /// short and smooth, about two thirds of the shapes' height at its waist. Joined parts read best at one height.
    static let joined: CGFloat = 4
    /// The gap between separate actions (menu items, confirm and cancel, chips): they rest as their own bubbles.
    static let apart: CGFloat = 26
    /// How far a bubble shrinks while it is home inside its parent.
    static let homeScale: CGFloat = 0.72

    /// A bubble leaving its parent: slow enough that the neck's stretch and snap read.
    static func split(reduceMotion: Bool) -> Animation {
        reduceMotion ? .easeOut(duration: 0.2) : .spring(duration: 0.62, bounce: 0.22)
    }

    /// A bubble going home. No bounce: a bounce would carry it out through the far side of its parent.
    static func home(reduceMotion: Bool) -> Animation {
        reduceMotion ? .easeIn(duration: 0.18) : .spring(duration: 0.5, bounce: 0)
    }
}

/// A group of glass shapes that merge into one liquid surface. On iOS 26 it is a `GlassEffectContainer`; before
/// that, and under Reduce Transparency, the shapes draw on their own and simply don't merge. `lift` adds the soft
/// shadow liquid glass floats on in light mode.
private struct PieceLiquidGroup<Content: View>: View {
    var spacing: CGFloat = PieceLiquid.merge
    var lift = true
    @ViewBuilder var content: Content
    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency
    @Environment(\.colorScheme) private var colorScheme

    var body: some View {
        container
            .shadow(color: .black.opacity(lift && colorScheme == .light ? 0.07 : 0), radius: 18, y: 8)
    }

    @ViewBuilder private var container: some View {
        #if compiler(>=6.2)
        if #available(iOS 26, *), !reduceTransparency {
            GlassEffectContainer(spacing: spacing) { content }
        } else {
            content
        }
        #else
        content
        #endif
    }
}

/// One liquid glass shape: Liquid Glass on iOS 26, carrying `tint` as a solid colour and swelling under a press when
/// `interactive`; a frosted Material with a light rim and a soft shadow before that; a solid fill under Reduce
/// Transparency.
///
/// The tint is painted inside clear glass rather than tinting the glass. Tinted glass in a group bleeds its colour
/// through every neck as a smear, so a red button would glow into the white pill it is joined to; painted inside,
/// the colour stays crisp to the shape's edge, the necks between shapes are clear glass, and a tint change animates
/// like any colour (tinted glass snaps).
private struct PieceLiquidSurface<S: Shape>: ViewModifier {
    var shape: S
    var tint: Color?
    var interactive: Bool
    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency
    @Environment(\.colorScheme) private var colorScheme
    @Environment(\.pieceLiquidScale) private var scale

    func body(content: Content) -> some View {
        #if compiler(>=6.2)
        if #available(iOS 26, *), !reduceTransparency {
            // Scaled as two parts, content and outline, about the same centre. A scaleEffect on a glass view inside a
            // GlassEffectContainer shrinks the glass but leaves what it carries full size, pinned to its corner.
            content
                .background { shape.fill(tint ?? .clear) }
                .scaleEffect(scale)
                .glassEffect(glass, in: shape.scale(scale))
        } else {
            fallback(content).scaleEffect(scale)
        }
        #else
        fallback(content).scaleEffect(scale)
        #endif
    }

    #if compiler(>=6.2)
    @available(iOS 26, *)
    private var glass: Glass {
        interactive ? Glass.regular.interactive() : .regular
    }
    #endif

    private func fallback(_ content: Content) -> some View {
        let dark = colorScheme == .dark
        return content
            .background {
                if reduceTransparency {
                    shape.fill(tint ?? (dark ? Color(white: 0.17) : Color(white: 0.97)))
                } else {
                    ZStack {
                        shape.fill(.regularMaterial)
                        if let tint { shape.fill(tint.opacity(0.88)) }
                    }
                }
            }
            .overlay { shape.stroke(Color.white.opacity(dark ? 0.14 : 0.7), lineWidth: 0.5) }
            .shadow(color: .black.opacity(dark ? 0.32 : 0.08), radius: 10, y: 5)
    }
}

private struct PieceLiquidScaleKey: EnvironmentKey {
    static let defaultValue: CGFloat = 1
}

private extension EnvironmentValues {
    /// How much the liquid shapes below are scaled, about their own centres. Nested scales multiply.
    var pieceLiquidScale: CGFloat {
        get { self[PieceLiquidScaleKey.self] }
        set { self[PieceLiquidScaleKey.self] = newValue }
    }
}

private extension View {
    /// Draws this view on a liquid glass `shape`. Put it inside a `PieceLiquidGroup` so it can merge with its neighbours.
    func pieceLiquid<S: Shape>(_ shape: S, tint: Color? = nil, interactive: Bool = true) -> some View {
        modifier(PieceLiquidSurface(shape: shape, tint: tint, interactive: interactive))
    }

    /// Scales the liquid glass shapes in this view, content and outline together, about their own centres. Use it
    /// instead of `scaleEffect` on a glass view (a press, a lift, a swell): inside a group a plain `scaleEffect` shrinks
    /// the glass but leaves its content full size and off centre. Animates like any other value.
    func pieceLiquidScale(_ scale: CGFloat) -> some View {
        transformEnvironment(\.pieceLiquidScale) { $0 *= scale }
    }
}

/// The press for a glass control: the same size-aware sink and lean as `piecePress`, applied through
/// `pieceLiquidScale` so the glass and what it carries sink together (a plain scaleEffect on glass leaves the content
/// behind). Put the glass inside what it presses: the label of a button, the view this modifies. Under Reduce Motion
/// it shades instead of moving.
private struct PieceLiquidPress: ViewModifier {
    let pressed: Bool
    var touch: CGPoint?
    var depth: CGFloat = 2.5
    @Environment(\.accessibilityReduceMotion) private var reduceMotion
    @Environment(\.colorScheme) private var colorScheme
    @State private var size: CGSize = .zero
    @State private var anchor: UnitPoint = .center

    func body(content: Content) -> some View {
        let motion = PieceMotion(reduceMotion: reduceMotion)
        let scale = pressed && !reduceMotion ? PieceMotion.pressScale(for: size, depth: depth) : 1
        // A scale about `anchor` is a scale about the centre plus this shift toward the anchor.
        let lean = CGSize(width: (anchor.x - 0.5) * size.width * (1 - scale), height: (anchor.y - 0.5) * size.height * (1 - scale))
        content
            .onGeometryChange(for: CGSize.self) { $0.size } action: { size = $0 }
            .brightness(pressed && reduceMotion ? (colorScheme == .dark ? 0.1 : -0.08) : 0)
            .pieceLiquidScale(scale)
            .offset(lean)
            .animation(pressed ? motion.press : motion.release, value: pressed)
            .onChange(of: pressed) { _, isPressed in
                if isPressed { anchor = PieceMotion.pressAnchor(touch: touch, in: size) }
            }
            .onChange(of: touch) { _, touch in
                if pressed, let touch { anchor = PieceMotion.pressAnchor(touch: touch, in: size) }
            }
    }
}

/// `PiecePressStyle` for glass buttons: the label (with its `.pieceLiquid` inside) sinks as one.
private struct PieceLiquidPressStyle: ButtonStyle {
    var depth: CGFloat = 2.5

    func makeBody(configuration: Configuration) -> some View {
        configuration.label.pieceLiquidPress(configuration.isPressed, depth: depth)
    }
}

private extension View {
    /// Sinks this view's glass while `pressed`, leaning toward `touch` (in this view's coordinates) when given.
    func pieceLiquidPress(_ pressed: Bool, touch: CGPoint? = nil, depth: CGFloat = 2.5) -> some View {
        modifier(PieceLiquidPress(pressed: pressed, touch: touch, depth: depth))
    }
}

/// The bud: how a bubble leaves and rejoins its parent, driven explicitly so every bubble shows the whole cycle.
///
/// A bubble is born at `home`, inside its parent, where the two glass shapes are one. It springs out to `rest`, and
/// while it is inside the merge distance a neck holds it to the parent, thinning as it goes, until it snaps free.
/// Going home it springs back on a spring with no bounce, the neck reaches out and re-forms, and only once it has
/// melted all the way in is it removed. Both offsets are relative to where the bubble is laid out. Under Reduce
/// Motion it stays at `rest`: its content fades and its glass closes in place.
private struct PieceBud: ViewModifier {
    var out: Bool
    var rest: CGSize
    var home: CGSize
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    func body(content: Content) -> some View {
        if reduceMotion {
            // No travel. Inside a group glass ignores opacity, so the glass closes to nothing in place on the short
            // Reduce Motion ease while its content fades; the opacity covers a bubble outside a group.
            content
                .pieceLiquidScale(out ? 1 : 0.001)
                .opacity(out ? 1 : 0)
                .offset(rest)
        } else {
            // The glass shrinks through `pieceLiquidScale`, never a plain scaleEffect (see there), then moves.
            content
                .pieceLiquidScale(out ? 1 : PieceLiquid.homeScale)
                .offset(out ? rest : home)
        }
    }
}

/// A bubble's own content, on its own clock: gone the moment the bubble heads home, so it never rides over the
/// parent's content, and arriving just after the bubble leaves.
private struct PieceBudContent: ViewModifier {
    var out: Bool

    func body(content: Content) -> some View {
        content
            .blur(radius: out ? 0 : 6)
            .opacity(out ? 1 : 0)
            .animation(out ? .easeOut(duration: 0.3).delay(0.1) : .easeOut(duration: 0.14), value: out)
    }
}

private extension View {
    /// Places a bubble at `rest` while `out`, and at `home` (inside its parent, shrunk) while not.
    func pieceBud(out: Bool, rest: CGSize = .zero, home: CGSize) -> some View {
        modifier(PieceBud(out: out, rest: rest, home: home))
    }

    /// Hides a bubble's icon or label while it is home. Put it on the content, inside the glass.
    func pieceBudContent(out: Bool) -> some View {
        modifier(PieceBudContent(out: out))
    }
}

/// Which bubbles exist and which are out. A bubble is added home with no animation, sent out on the next frame,
/// and called home before it is removed, so it always melts in rather than fading. Keep one in `@State`.
@MainActor @Observable
private final class PieceBuds {
    private(set) var present: [String] = []
    private(set) var out: Set<String> = []
    /// The latest call for each bubble. A bloom or gather that has been overtaken (a bubble sent home while it was
    /// still waiting to go out, or called out again while melting) leaves that bubble alone.
    @ObservationIgnored private var turn: [String: Int] = [:]

    func contains(_ id: String) -> Bool { present.contains(id) }
    func isOut(_ id: String) -> Bool { out.contains(id) }

    private func claim(_ ids: [String]) -> [String: Int] {
        var mine: [String: Int] = [:]
        for id in ids {
            let next = (turn[id] ?? 0) + 1
            turn[id] = next
            mine[id] = next
        }
        return mine
    }

    /// Puts bubbles straight out at rest with no motion: a view's first frame, or a state restored.
    func place(_ ids: [String]) {
        _ = claim(ids)
        var quiet = Transaction()
        quiet.disablesAnimations = true
        withTransaction(quiet) {
            for id in ids where !present.contains(id) { present.append(id) }
            out.formUnion(ids)
        }
    }

    /// Adds bubbles home, then sends each out, `stagger` seconds apart, after an optional `delay`.
    func bloom(_ ids: [String], reduceMotion: Bool, stagger: Double = 0.05, delay: Double = 0) async {
        let mine = claim(ids)
        var quiet = Transaction()
        quiet.disablesAnimations = true
        withTransaction(quiet) {
            for id in ids where !present.contains(id) { present.append(id) }
        }
        try? await Task.sleep(for: .milliseconds(24 + Int(max(delay, 0) * 1000)))
        let split = PieceLiquid.split(reduceMotion: reduceMotion)
        for (i, id) in ids.enumerated() where turn[id] == mine[id] {
            withAnimation(split.delay(reduceMotion ? 0 : Double(i) * stagger)) { _ = out.insert(id) }
        }
    }

    /// Calls bubbles home, last first, then removes them once they have melted in.
    func gather(_ ids: [String], reduceMotion: Bool, stagger: Double = 0.04) async {
        let mine = claim(ids)
        let home = PieceLiquid.home(reduceMotion: reduceMotion)
        for (i, id) in ids.reversed().enumerated() {
            withAnimation(home.delay(reduceMotion ? 0 : Double(i) * stagger)) { _ = out.remove(id) }
        }
        try? await Task.sleep(for: .milliseconds(Int((0.52 + Double(ids.count) * stagger) * 1000)))
        var quiet = Transaction()
        quiet.disablesAnimations = true
        withTransaction(quiet) { present.removeAll { ids.contains($0) && !out.contains($0) && turn[$0] == mine[$0] } }
    }
}

/// A label that changes letter by letter: letters both strings share hold still, the rest blur out and the new ones
/// blur in a few milliseconds apart. Under Reduce Motion it cross-fades. VoiceOver reads the whole string.
///
/// Only text whose letters stand on their own is cut into letters: Latin, Greek, Cyrillic, CJK, digits and symbols.
/// Those letters are laid out left to right whatever the layout direction, the order they read in, so "1.5×" stays
/// "1.5×" in an Arabic or Hebrew interface instead of coming out backwards. Text in a right-to-left script, or in one
/// whose letters join or reorder (Arabic, Hebrew, Devanagari, Thai and their neighbours), can't be cut apart without
/// breaking it, so it changes as one: the old string blurs out where it stood while the new one blurs in.
private struct PieceMorphText: View {
    var text: String
    var font: Font = .body.weight(.semibold)
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    var body: some View {
        // The morphing label at its full size when it fits. When it doesn't (a long label at an accessibility text
        // size, a narrow screen), the same words wrap onto a second line and shrink a little instead of running past
        // the screen's edge; that one changes as a whole rather than letter by letter. A single word never splits
        // across lines: it stays on one and shrinks further.
        let oneWord = !text.contains(where: \.isWhitespace)
        ViewThatFits(in: .horizontal) {
            morphing.fixedSize()
            Text(text)
                .lineLimit(oneWord ? 1 : 2)
                .multilineTextAlignment(.center)
                .minimumScaleFactor(oneWord ? 0.5 : 0.75)
                .fixedSize(horizontal: false, vertical: true)
                .id(text)
                .transition(transition(0, scale: 0.9))
        }
        .font(font)
        .accessibilityElement(children: .ignore)
        .accessibilityLabel(text)
    }

    @ViewBuilder private var morphing: some View {
        if Self.splits(text) {
            let glyphs = Array(text)
            HStack(spacing: 0) {
                ForEach(glyphs.indices, id: \.self) { i in
                    Text(String(glyphs[i]))
                        .id("\(i)\(glyphs[i])")
                        .transition(transition(i, scale: 0.6))
                }
            }
            // The letters' reading order, not the layout's: an HStack lays its children out backwards under a
            // right-to-left layout.
            .environment(\.layoutDirection, .leftToRight)
        } else {
            ZStack(alignment: .leading) {
                Text(text)
                    .id(text)
                    .transition(transition(0, scale: 0.9))
            }
        }
    }

    private func transition(_ i: Int, scale: CGFloat) -> AnyTransition {
        guard !reduceMotion else { return .opacity }
        return AnyTransition(.blurReplace(.downUp)).combined(with: .scale(scale: scale, anchor: .bottom))
            .animation(.spring(duration: 0.42, bounce: 0.3).delay(Double(i) * 0.022))
    }

    /// Whether `text` can be cut into letters that each read left to right on their own: no right-to-left script, no
    /// script that joins or reorders its letters, and no bidirectional control characters.
    private static func splits(_ text: String) -> Bool {
        !text.unicodeScalars.contains { scalar in
            switch scalar.value {
            case 0x0590...0x08FF, // Hebrew, Arabic, Syriac, Thaana, NKo, Samaritan, Mandaic
                 0x0900...0x0DFF, // Devanagari to Sinhala
                 0x0E00...0x0FFF, // Thai, Lao, Tibetan
                 0x1000...0x109F, // Myanmar
                 0x1780...0x17FF, // Khmer
                 0xA8E0...0xA8FF, // Devanagari Extended
                 0xFB1D...0xFDFF, // Hebrew and Arabic presentation forms
                 0xFE70...0xFEFF, // Arabic presentation forms B
                 0x200E...0x200F, 0x202A...0x202E, 0x2066...0x2069, // bidirectional marks, embeddings and isolates
                 0x10800...0x10FFF, // historic right-to-left scripts
                 0x1E800...0x1EFFF: // Adlam and other right-to-left scripts
                return true
            default:
                return false
            }
        }
    }
}

// swiftpieces-liquid: end