crossmate

AnnouncementBanner.swift (5821B)

---

 import SwiftUI
 
 /// Banner-style surface for an `Announcement`. Renders a severity rail, icon,
 /// and body text over a neutral material background. Manual announcements get
 /// a close affordance; transient and sticky announcements do not.
 struct AnnouncementBanner: View {
     enum ContentSize {
         case compact
         case prominent
 
         var childSpacing: CGFloat {
             switch self {
             case .compact: return 8
             case .prominent: return 10
             }
         }
 
         var iconFont: Font {
             switch self {
             case .compact: return .footnote.weight(.semibold)
             case .prominent: return .subheadline.weight(.semibold)
             }
         }
 
         var titleFont: Font {
             switch self {
             case .compact: return .subheadline.weight(.semibold)
             case .prominent: return .callout.weight(.semibold)
             }
         }
 
         var bodyFont: Font {
             switch self {
             case .compact: return .subheadline
             case .prominent: return .callout
             }
         }
     }
 
     let announcement: Announcement
     /// When true the banner stretches to the height its container proposes
     /// (PuzzleView's fixed-height header slot); by default it hugs its text,
     /// which is what inline placements like the game list need.
     var fillsAvailableHeight = false
     /// Whether to show the leading severity icon. The Settings tips archive
     /// turns it off — the rail alone carries the tip styling there.
     var showsIcon = true
     /// Visual density for the banner content. Puzzle-header announcements use
     /// the compact default; Game List announcements opt into larger text.
     var contentSize: ContentSize = .compact
     /// Fill behind the banner. Defaults to the inset-grouped section fill so
     /// banners read as solid cards on the grouped Game List and in the Settings
     /// tips archive; override per surface if a different fill is wanted.
     var background: AnyShapeStyle = AnyShapeStyle(Color(.secondarySystemGroupedBackground))
     let onDismiss: (() -> Void)?
 
     var body: some View {
         let severityColor = tint(for: announcement.severity)
         HStack(alignment: .center, spacing: contentSize.childSpacing) {
             if showsIcon {
                 Image(systemName: iconName(for: announcement.severity))
                     .font(contentSize.iconFont)
                     .foregroundStyle(severityColor)
                     .frame(width: 24)
                     .accessibilityHidden(true)
             }
 
             VStack(alignment: .leading, spacing: 3) {
                 if let title = announcement.title, !title.isEmpty {
                     Text(title)
                         .font(contentSize.titleFont)
                         .lineLimit(1)
                 }
                 Text(announcement.body)
                     .font(contentSize.bodyFont)
                     .foregroundStyle(.primary)
                     .multilineTextAlignment(.leading)
                     .lineLimit(3)
             }
             .frame(maxWidth: .infinity, alignment: .leading)
 
             if case .manual = announcement.dismissal {
                 Button {
                     onDismiss?()
                 } label: {
                     Image(systemName: "xmark.circle.fill")
                         .font(.callout)
                         .symbolRenderingMode(.hierarchical)
                 }
                 .buttonStyle(.plain)
                 .foregroundStyle(.secondary)
                 .accessibilityLabel("Dismiss announcement")
             }
         }
         .padding(.horizontal, 10)
         .padding(.vertical, 10)
         // Without the icon the text would otherwise crowd the severity rail;
         // give it a little extra breathing room on the leading edge.
         .padding(.leading, showsIcon ? 4 : 12)
         .frame(
             maxWidth: .infinity,
             maxHeight: fillsAvailableHeight ? .infinity : nil,
             alignment: .leading
         )
         .background(background, in: RoundedRectangle(cornerRadius: 8, style: .continuous))
         // The severity rail is drawn as an overlay rather than laid out as an
         // HStack child: a width-constrained `Rectangle` in the HStack is
         // greedy for height, which made the whole banner expand to fill
         // whatever its container offered instead of hugging the text.
         .overlay(alignment: .leading) {
             Rectangle()
                 .fill(severityColor)
                 .frame(width: 4)
                 .accessibilityHidden(true)
         }
         .overlay {
             RoundedRectangle(cornerRadius: 8, style: .continuous)
                 .strokeBorder(Color.primary.opacity(0.08), lineWidth: 1)
         }
         .clipShape(RoundedRectangle(cornerRadius: 8, style: .continuous))
         .contentShape(Rectangle())
         .onTapGesture {
             // `.transient` self-dismisses; `.sticky` requires programmatic
             // dismissal. Only `.manual` reacts to a tap.
             guard case .manual = announcement.dismissal else { return }
             onDismiss?()
         }
         .accessibilityElement(children: .combine)
     }
 
     /// SF Symbol that leads the banner text, one per severity.
     private func iconName(for severity: Announcement.Severity) -> String {
         switch severity {
         case .tip: return "lightbulb"
         case .info: return "bell"
         case .warning: return "exclamationmark.triangle"
         case .error: return "xmark.octagon"
         }
     }
 
     private func tint(for severity: Announcement.Severity) -> Color {
         switch severity {
         case .tip: return .yellow
         case .info: return .blue
         case .warning: return .orange
         case .error: return .red
         }
     }
 }