5f:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 60:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 61:T72e,import SwiftUI @available(macOS, unavailable) @MainActor public protocol FLXToastStyle { associatedtype Body: View typealias Configuration = FLXToastStyleConfiguration @ViewBuilder func makeBody(configuration: Configuration) -> Body } @available(macOS, unavailable) public struct FLXToastStyleConfiguration { // The caller's actions plus the close button. Nil when the toast has no // actions, so it dismisses on its own. public struct Actions: View { let underlyingActions: AnyView public var body: some View { underlyingActions } } public let title: Text public let message: Text? public let systemImage: String? public let actions: Actions? } @available(macOS, unavailable) public struct FLXDefaultToastStyle: FLXToastStyle { public init() {} public func makeBody(configuration: Configuration) -> some View { FLXToastStyleBody(configuration: configuration) } } @available(macOS, unavailable) struct AnyFLXToastStyle: FLXToastStyle { private let _makeBody: (Configuration) -> AnyView init(_ style: S) { _makeBody = { AnyView(style.makeBody(configuration: $0)) } } func makeBody(configuration: Configuration) -> AnyView { _makeBody(configuration) } } @available(macOS, unavailable) private struct FLXToastStyleKey: EnvironmentKey { static let defaultValue: AnyFLXToastStyle? = nil } @available(macOS, unavailable) extension EnvironmentValues { var flxToastStyle: AnyFLXToastStyle? { get { self[FLXToastStyleKey.self] } set { self[FLXToastStyleKey.self] = newValue } } } @available(macOS, unavailable) extension View { public func flxToastStyle(_ style: S) -> some View { environment(\.flxToastStyle, AnyFLXToastStyle(style)) } } 62:T2607,import SwiftUI // Compiled on every platform so the shared files build, but unavailable on // macOS until it has its own rendering and behavior file. private enum FLXToastMetrics { static let maxWidth: CGFloat = 420 static let cornerRadius: CGFloat = 24 static let timerStep: Duration = .milliseconds(100) static let dismissDistance: CGFloat = 60 static let resistance: CGFloat = 6 } // Draws the slot's toast over the view it's attached to, and runs its timer. @available(macOS, unavailable) struct FLXToastHost: ViewModifier { @ObservedObject var slot: FLXToastSlot @Environment(\.accessibilityReduceMotion) private var reduceMotion @Environment(\.accessibilityVoiceOverEnabled) private var voiceOver @Environment(\.scenePhase) private var scenePhase @State private var isHovering = false @State private var dragOffset: CGFloat = 0 // VoiceOver users need time to reach the toast, so it never times out for them. private var isPaused: Bool { voiceOver || isHovering || dragOffset != 0 || scenePhase != .active } private var alignment: Alignment { switch slot.edge { case .top: .top case .bottom: .bottom } } func body(content: Content) -> some View { content .overlay(alignment: alignment) { ZStack { if let entry = slot.current { toast(entry) .id(entry.key) .transition(transition(entry.edge)) } } .padding(.horizontal, FLXSpacing.lg) .padding(.vertical, FLXSpacing.sm) } .animation(.default, value: slot.current?.key) .task(id: slot.current?.key) { await present() } } private func transition(_ edge: VerticalEdge) -> AnyTransition { if reduceMotion { return .opacity } switch edge { case .top: return .move(edge: .top).combined(with: .opacity) case .bottom: return .move(edge: .bottom).combined(with: .opacity) } } private func toast(_ entry: FLXToastSlot.Entry) -> some View { (entry.style ?? AnyFLXToastStyle(FLXDefaultToastStyle())) .makeBody(configuration: configuration(entry)) .offset(y: dragOffset) .gesture(swipe(entry)) .onHover { isHovering = $0 } .accessibilityAction(.escape) { close(entry) } } private func configuration(_ entry: FLXToastSlot.Entry) -> FLXToastStyleConfiguration { FLXToastStyleConfiguration( title: entry.content.title, message: entry.content.message, systemImage: entry.content.systemImage, actions: entry.content.actions.map { actions in FLXToastStyleConfiguration.Actions( underlyingActions: AnyView( HStack(spacing: FLXSpacing.sm) { actions FLXToastCloseButton { close(entry) } } .buttonStyle(FLXToastActionButtonStyle { close(entry) }) ) ) } ) } private func swipe(_ entry: FLXToastSlot.Entry) -> some Gesture { DragGesture() .onChanged { value in let height = value.translation.height if isTowardsEdge(height, entry.edge) { dragOffset = height } else { dragOffset = height / FLXToastMetrics.resistance } } .onEnded { value in let predicted = value.predictedEndTranslation.height if isTowardsEdge(predicted, entry.edge) && abs(predicted) > FLXToastMetrics.dismissDistance { close(entry) } withAnimation(.default) { dragOffset = 0 } } } private func isTowardsEdge(_ height: CGFloat, _ edge: VerticalEdge) -> Bool { switch edge { case .top: height < 0 case .bottom: height > 0 } } private func close(_ entry: FLXToastSlot.Entry) { entry.dismiss() slot.clear(owner: entry.owner) } // Without a duration, the toast stays until the person acts on it or closes it. private func present() async { guard let entry = slot.current else { return } announce(entry.content.announcement) guard let duration = entry.duration else { return } var elapsed: Duration = .zero while elapsed < duration { do { try await Task.sleep(for: FLXToastMetrics.timerStep) } catch { return } if !isPaused { elapsed += FLXToastMetrics.timerStep } } close(entry) } private func announce(_ announcement: String) { if #available(iOS 17, macOS 14, *) { AccessibilityNotification.Announcement(announcement).post() } } } @available(macOS, unavailable) struct FLXToastStyleBody: View { @ScaledMetric(relativeTo: .subheadline) private var scale: CGFloat = 1 let configuration: FLXToastStyleConfiguration // The surface wraps the finished layout, as Apple asks of glass, so it // follows the presentation transition. One shape serves both layouts: the // corner reaches half the one-line height, which reads as a capsule, and // taller content gets the rounded rectangle Apple recommends. var body: some View { ViewThatFits(in: .horizontal) { row .padding(.horizontal, FLXSpacing.lg) .padding(.vertical, FLXSpacing.md) stacked .padding(FLXSpacing.lg) } .frame(maxWidth: FLXToastMetrics.maxWidth) .modifier( FLXToastSurface( shape: RoundedRectangle(cornerRadius: FLXToastMetrics.cornerRadius * scale, style: .continuous) ) ) .accessibilityElement(children: .contain) } private var row: some View { HStack(spacing: FLXSpacing.md) { icon texts Spacer(minLength: 0) actions } } // Large Dynamic Type sizes and long text move the actions below the text. private var stacked: some View { VStack(alignment: .leading, spacing: FLXSpacing.md) { HStack(alignment: .firstTextBaseline, spacing: FLXSpacing.md) { icon texts Spacer(minLength: 0) } if configuration.actions != nil { HStack { Spacer(minLength: 0) actions } } } } @ViewBuilder private var icon: some View { if let systemImage = configuration.systemImage { Image(systemName: systemImage) .imageScale(.large) .foregroundStyle(.tint) .accessibilityHidden(true) } } // Hierarchical styles keep the system's vibrancy over glass and materials. private var texts: some View { VStack(alignment: .leading) { configuration.title .flxFont(.subheadline, weight: .semibold) .foregroundStyle(.primary) if let message = configuration.message { message .flxFont(.footnote) .foregroundStyle(.secondary) } } } @ViewBuilder private var actions: some View { if let actions = configuration.actions { actions .buttonStyle(.borderless) .flxFont(.subheadline, weight: .semibold) } } } // The floating surface belongs to the system: Liquid Glass where available, // the regular material before it. The theme only reaches it through tint. @available(macOS, unavailable) struct FLXToastSurface: ViewModifier { let shape: S func body(content: Content) -> some View { if #available(iOS 26, macOS 26, *) { content.glassEffect(.regular, in: shape) } else { content.background(.regularMaterial, in: shape) } } } // Like an alert, any action dismisses the toast. A primitive style sees every // activation (touch, VoiceOver, keyboard), and the Button it creates still // takes the appearance from the styles applied further out. It dismisses // first, so an action that presents a new toast isn't cancelled. @available(macOS, unavailable) struct FLXToastActionButtonStyle: PrimitiveButtonStyle { let dismiss: () -> Void func makeBody(configuration: Configuration) -> some View { Button(role: configuration.role) { dismiss() configuration.trigger() } label: { configuration.label } } } // Swipe needs a button alternative. The close role brings the system symbol // and its translated label. @available(macOS, unavailable) struct FLXToastCloseButton: View { let action: () -> Void var body: some View { closeButton .labelStyle(.iconOnly) .foregroundStyle(.secondary) } @ViewBuilder private var closeButton: some View { if #available(iOS 26, macOS 26, *) { Button(role: .close, action: action) } else { Button(action: action) { Label("Close", systemImage: "xmark") } } } } 63:T32ab,import Combine import SwiftUI // Titles and messages are text, not views, because VoiceOver announcements // need a String: a LocalizedStringKey or an arbitrary view can't be read back. // LocalizedStringResource keeps them translated and extracted by Xcode. // // A title can also be a String shown as is, such as a file name. A message is // always a LocalizedStringResource: a String overload would make Swift pick it // for literals too, and the copy would silently stop being translated. Runtime // text goes in through interpolation, `message: "\(detail)"`. // // Actions take the toast's button style, which also dismisses the toast. Like // an alert's, they shouldn't get their own `.buttonStyle(_:)`: the innermost // style wins, so that button would no longer dismiss the toast. @available(macOS, unavailable) extension View { // Only toasts without actions time out. A toast with actions stays until // the person acts on it or closes it, so it takes no duration. public func flxToast( _ titleResource: LocalizedStringResource, systemImage: String? = nil, isPresented: Binding, message: LocalizedStringResource? = nil, edge: VerticalEdge = .top, duration: Duration = .seconds(4) ) -> some View { modifier( FLXToastPresenter( isPresented: isPresented.wrappedValue, identity: nil, content: FLXToastContent(title: titleResource, message: message, systemImage: systemImage, actions: EmptyView()), edge: edge, duration: duration, dismiss: { isPresented.wrappedValue = false } ) ) } public func flxToast( _ titleResource: LocalizedStringResource, systemImage: String? = nil, isPresented: Binding, message: LocalizedStringResource? = nil, edge: VerticalEdge = .top, @ViewBuilder actions: () -> A ) -> some View { modifier( FLXToastPresenter( isPresented: isPresented.wrappedValue, identity: nil, content: FLXToastContent(title: titleResource, message: message, systemImage: systemImage, actions: actions()), edge: edge, duration: nil, dismiss: { isPresented.wrappedValue = false } ) ) } @_disfavoredOverload public func flxToast( _ title: S, systemImage: String? = nil, isPresented: Binding, message: LocalizedStringResource? = nil, edge: VerticalEdge = .top, duration: Duration = .seconds(4) ) -> some View { modifier( FLXToastPresenter( isPresented: isPresented.wrappedValue, identity: nil, content: FLXToastContent(title: title, message: message, systemImage: systemImage, actions: EmptyView()), edge: edge, duration: duration, dismiss: { isPresented.wrappedValue = false } ) ) } @_disfavoredOverload public func flxToast( _ title: S, systemImage: String? = nil, isPresented: Binding, message: LocalizedStringResource? = nil, edge: VerticalEdge = .top, @ViewBuilder actions: () -> A ) -> some View { modifier( FLXToastPresenter( isPresented: isPresented.wrappedValue, identity: nil, content: FLXToastContent(title: title, message: message, systemImage: systemImage, actions: actions()), edge: edge, duration: nil, dismiss: { isPresented.wrappedValue = false } ) ) } public func flxToast( item: Binding, systemImage: String? = nil, edge: VerticalEdge = .top, duration: Duration = .seconds(4), title: (T) -> LocalizedStringResource, message: ((T) -> LocalizedStringResource)? = nil ) -> some View { itemToast(item: item, edge: edge, duration: duration) { value in FLXToastContent(title: title(value), message: message.map { $0(value) }, systemImage: systemImage, actions: EmptyView()) } } // A new `id` replaces the toast on screen; the same `id` with new data // updates it in place without restarting its timer. public func flxToast( item: Binding, systemImage: String? = nil, edge: VerticalEdge = .top, title: (T) -> LocalizedStringResource, message: ((T) -> LocalizedStringResource)? = nil, @ViewBuilder actions: (T) -> A ) -> some View { itemToast(item: item, edge: edge, duration: nil) { value in FLXToastContent(title: title(value), message: message.map { $0(value) }, systemImage: systemImage, actions: actions(value)) } } @_disfavoredOverload public func flxToast( item: Binding, systemImage: String? = nil, edge: VerticalEdge = .top, duration: Duration = .seconds(4), title: (T) -> S, message: ((T) -> LocalizedStringResource)? = nil ) -> some View { itemToast(item: item, edge: edge, duration: duration) { value in FLXToastContent(title: title(value), message: message.map { $0(value) }, systemImage: systemImage, actions: EmptyView()) } } @_disfavoredOverload public func flxToast( item: Binding, systemImage: String? = nil, edge: VerticalEdge = .top, title: (T) -> S, message: ((T) -> LocalizedStringResource)? = nil, @ViewBuilder actions: (T) -> A ) -> some View { itemToast(item: item, edge: edge, duration: nil) { value in FLXToastContent(title: title(value), message: message.map { $0(value) }, systemImage: systemImage, actions: actions(value)) } } private func itemToast( item: Binding, edge: VerticalEdge, duration: Duration?, content: (T) -> FLXToastContent ) -> some View { let value = item.wrappedValue return modifier( FLXToastPresenter( isPresented: value != nil, identity: value.map { AnyHashable($0.id) }, content: value.map(content), edge: edge, duration: duration, dismiss: { item.wrappedValue = nil } ) ) } } // One toast at a time, with no setup. The outermost toast modifier owns the // slot and hands it down through the environment, so every toast inside it // replaces the one on screen instead of drawing over it. A sheet keeps its own // slot: preferences don't cross a presentation, so the slot behind the sheet // never sees the toasts declared in it. @available(macOS, unavailable) struct FLXToastPresenter: ViewModifier { let isPresented: Bool let identity: AnyHashable? let content: FLXToastContent? let edge: VerticalEdge let duration: Duration? let dismiss: () -> Void @Environment(\.flxToastSlot) private var outer @StateObject private var own = FLXToastSlot() @State private var id = UUID() func body(content view: Content) -> some View { view.modifier( FLXToastRouter( request: self, id: id, outer: outer ?? own, own: own ) ) } } @available(macOS, unavailable) struct FLXToastRouter: ViewModifier { let request: FLXToastPresenter let id: UUID @ObservedObject var outer: FLXToastSlot @ObservedObject var own: FLXToastSlot @Environment(\.flxToastStyle) private var style private struct SyncKey: Hashable { var isPresented: Bool var identity: AnyHashable? var announcement: String? var isRouted: Bool } private var isRouted: Bool { outer !== own && outer.reachable.contains(id) } private var target: FLXToastSlot { if isRouted { return outer } return own } // The announcement stands in for the content: same `id` with new text // updates the toast in place. private var syncKey: SyncKey { SyncKey( isPresented: request.isPresented, identity: request.identity, announcement: request.content?.announcement, isRouted: isRouted ) } func body(content: Content) -> some View { content .onPreferenceChange(FLXToastSlotMembers.self) { members in own.reachable = members } .environment(\.flxToastSlot, target) .transformPreference(FLXToastSlotMembers.self) { members in members.insert(id) } .modifier(FLXToastHost(slot: own)) .task(id: syncKey) { sync() } } private func sync() { guard request.isPresented, let content = request.content else { outer.clear(owner: id) own.clear(owner: id) return } target.present( FLXToastSlot.Entry( owner: id, identity: request.identity, content: content, style: style, edge: request.edge, duration: request.duration, dismiss: request.dismiss ) ) } } @available(macOS, unavailable) @MainActor final class FLXToastSlot: ObservableObject { struct Key: Hashable { let owner: UUID let identity: AnyHashable? } struct Entry { let owner: UUID let identity: AnyHashable? let content: FLXToastContent let style: AnyFLXToastStyle? let edge: VerticalEdge let duration: Duration? let dismiss: () -> Void var key: Key { Key(owner: owner, identity: identity) } } @Published private(set) var current: Entry? // Kept after dismissal so the leaving toast exits through its own edge. @Published private(set) var edge: VerticalEdge = .top @Published var reachable: Set = [] // A toast from another modifier is dismissed, so its binding shows it's gone. func present(_ entry: Entry) { if let current, current.owner != entry.owner { current.dismiss() } edge = entry.edge current = entry } func clear(owner: UUID) { if current?.owner == owner { current = nil } } } @available(macOS, unavailable) private struct FLXToastSlotKey: EnvironmentKey { static let defaultValue: FLXToastSlot? = nil } @available(macOS, unavailable) extension EnvironmentValues { var flxToastSlot: FLXToastSlot? { get { self[FLXToastSlotKey.self] } set { self[FLXToastSlotKey.self] = newValue } } } @available(macOS, unavailable) private struct FLXToastSlotMembers: PreferenceKey { static let defaultValue: Set = [] static func reduce(value: inout Set, nextValue: () -> Set) { value.formUnion(nextValue()) } } @available(macOS, unavailable) struct FLXToastContent { let title: Text let message: Text? let systemImage: String? let actions: AnyView? let announcement: String init(title: LocalizedStringResource, message: LocalizedStringResource?, systemImage: String?, actions: A) { self.init( title: Text(title), titleString: String(localized: title), message: message.map { Text($0) }, messageString: message.map { String(localized: $0) }, systemImage: systemImage, actions: actions ) } init(title: S, message: LocalizedStringResource?, systemImage: String?, actions: A) { self.init( title: Text(title), titleString: String(title), message: message.map { Text($0) }, messageString: message.map { String(localized: $0) }, systemImage: systemImage, actions: actions ) } private init(title: Text, titleString: String, message: Text?, messageString: String?, systemImage: String?, actions: A) { self.title = title self.message = message self.systemImage = systemImage self.announcement = [titleString, messageString].compactMap { $0 }.joined(separator: ". ") if A.self == EmptyView.self { self.actions = nil } else { self.actions = AnyView(actions) } } } 5e:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[null,["$","$L5f",null,{"namespace":"@swiftui-flx","registryDependencies":["@swiftui-flx/foundation"]}]]}],null]}],["$","$L60",null,{"files":[{"path":"registry/components/toast/FLXToastStyle.swift","content":"$61","type":"registry:file","target":"~/DesignSystem/Components/FLXToast/FLXToastStyle.swift"},{"path":"registry/components/toast/FLXToastStyle+iOS.swift","content":"$62","type":"registry:file","target":"~/DesignSystem/Components/FLXToast/FLXToastStyle+iOS.swift"},{"path":"registry/components/toast/FLXToast.swift","content":"$63","type":"registry:file","target":"~/DesignSystem/Components/FLXToast/FLXToast.swift"}],"className":"h-[70svh] min-h-80"}]]}]