Luma/t

 
Sources/Shared/UI/ChatView.swift
────────────────────────────────────────────────────────────────────────────────────────────
 
────────────────────────────┐
75: struct ChatView: View { │
────────────────────────────┘
@State private var captureSuspendsArchiveSync = false
@State private var pickerResetToken = UUID()
@State private var timelineEntries: [ChatTimelineEntry] = []
/// Messages-style entrance state: which rows currently animate, which IDs
/// the timeline already showed, and whether the opening cascade of this
/// conversation has played.
@State private var entranceModes: [String: MessageBubbleEntrance.Mode] = [:]
@State private var knownEntranceIDs: Set<String> = []
@State private var hasPlayedOpeningEntrance = false
@State private var entranceReleaseToken = UUID()
 
/// Messages of this conversation straight from the SwiftData store,
/// ordered like `AppModel.selectedMessages`: timestamp, then clientID.
 
─────────────────────────────┐
150: struct ChatView: View { │
─────────────────────────────┘
_captureSuspendsArchiveSync = State(initialValue: false)
_pickerResetToken = State(initialValue: UUID())
_timelineEntries = State<[ChatTimelineEntry]>(initialValue: [])
_entranceModes = State<[String: MessageBubbleEntrance.Mode]>(
initialValue: [:]
)
_knownEntranceIDs = State<Set<String>>(initialValue: [])
_hasPlayedOpeningEntrance = State(initialValue: false)
_entranceConversationID = State<String?>(initialValue: nil)
_entranceReleaseToken = State(initialValue: UUID())
}
 
var body: some View {
 
─────────────────────────────┐
390: struct ChatView: View { │
─────────────────────────────┘
historyTopTriggerVisible = false
historyAutoContinueCount = 0
emptyHistoryRetryCount = 0
entranceModes = [:]
knownEntranceIDs = []
hasPlayedOpeningEntrance = false
entranceReleaseToken = UUID()
}
.onDisappear {
model.endConversationViewing(jid: conversation.jid)
 
─────────────────────────────┐
496: struct ChatView: View { │
─────────────────────────────┘
 
private func rebuildTimelineEntries(from newMessages: [ChatMessage]? = nil)
{
timelineEntries = ChatTimelineEntry.make(from: newMessages ?? messages)
let source = newMessages ?? messages
timelineEntries = ChatTimelineEntry.make(from: source)
updateEntranceModes(for: source)
}
 
/// Decides which rows play a Messages-style entrance after a rebuild.
/// The first page of an opened conversation cascades bottom-up; rows that
/// appear later (a send, an incoming message) launch from the composer's
/// edge. Modes are released once the animation window closes so a row
/// recycled by the lazy stack during scrolling reappears statically.
private func updateEntranceModes(for newMessages: [ChatMessage]) {
let ids = newMessages.map(\.clientID)
let known = knownEntranceIDs
knownEntranceIDs = Set(ids)
 
guard hasPlayedOpeningEntrance else {
guard !ids.isEmpty else { return }
hasPlayedOpeningEntrance = true
// The first message ever in an empty chat should launch out of
// the composer like any other send, not cascade in.
if ids.count == 1, known.isEmpty,
newMessages.first?.direction == .outgoing
{
applyLaunch(for: newMessages, ids: ids)
return
}
let delays = ChatMessageEntrancePolicy.entranceDelays(
forIDs: ids
)
for (id, delay) in delays {
entranceModes[id] = .cascade(delay: delay)
}
scheduleEntranceRelease(
ids: Set(delays.keys),
after: ChatMessageEntrancePolicy.entranceCascadeDuration
)
return
}
 
applyLaunch(
for: newMessages,
ids: ChatMessageEntrancePolicy.appendedLaunchIDs(
in: ids,
after: known
)
)
}
 
private func applyLaunch(for messages: [ChatMessage], ids: [String]) {
guard !ids.isEmpty else { return }
let launched = Set(ids)
var applied: Set<String> = []
for message in messages where launched.contains(message.clientID) {
entranceModes[message.clientID] = .launch(
outgoing: message.direction == .outgoing
)
applied.insert(message.clientID)
}
scheduleEntranceRelease(
ids: applied,
after: ChatMessageEntrancePolicy.entranceAnimationDuration
)
}
 
private func scheduleEntranceRelease(
ids: Set<String>,
after delay: TimeInterval
) {
guard !ids.isEmpty else { return }
let token = entranceReleaseToken
Task { @MainActor in
try? await Task.sleep(
nanoseconds: UInt64(delay * 1_000_000_000)
)
guard !Task.isCancelled, token == entranceReleaseToken else {
return
}
for id in ids {
entranceModes[id] = nil
}
}
}
 
private var isSelectingMessages: Bool {
 
─────────────────────────────┐
704: struct ChatView: View { │
─────────────────────────────┘
)
}
)
.modifier(
MessageBubbleEntrance(
mode: entranceModes[
message.clientID
] ?? .settled
)
)
.id(message.clientID)
}
}