Move schedule day section title calculation logic to view layer

Author: asiliuk

Modules/Sources/ScheduleFeature/Schedule/Day/DaySectionFeature.swift

@@ -17,23 +17,10 @@ public struct DaySectionFeature {
             case past
             case today
             case future
-
-            fileprivate init(for date: Date, now: Date, calendar: Calendar) {
-                if calendar.isDate(date, inSameDayAs: now) {
-                    self = .today
-                } else if date < now {
-                    self = .past
-                } else {
-                    self = .future
-                }
-            }
         }
 
         public var id: UUID
         var dayDate: DayDate
-        var title: String = ""
-        var subtitle: String? = nil
-        var relativity: Relativity = .future
         var pairRows: IdentifiedArrayOf<PairRowFeature.State>
 
         init(
@@ -61,40 +48,65 @@ public struct DaySectionFeature {
 
     @CasePathable
     public enum Action {
-        case onAppear
         case pairRows(IdentifiedActionOf<PairRowFeature>)
     }
 
-    @Dependency(\.date.now) var now
-    @Dependency(\.calendar) var calendar
-
     public var body: some ReducerOf<Self> {
-        Reduce { state, action in
-            switch action {
-            case .onAppear:
-                switch state.dayDate {
-                case .continuousDate(let date, let weekNumber):
-                    state.title = String(localized: "screen.schedule.day.title.\(date.formatted(.scheduleDay)).\(weekNumber)")
-                    state.subtitle = Self.relativeFormatter.relativeName(for: date, now: now)
-                    state.relativity = State.Relativity(for: date, now: now, calendar: calendar)
-                case .weekday(let weekday):
-                    state.title = weekday.localizedName(in: calendar).capitalized
-                    state.subtitle = nil
-                    state.relativity = .future
-                case .examDate(let date):
-                    state.title = date?.formatted(.examDay) ?? "-/-"
-                    state.subtitle = date.flatMap { Self.relativeFormatter.relativeName(for: $0, now: now) }
-                    state.relativity = date.map { State.Relativity(for: $0, now: now, calendar: calendar) } ?? .future
-                }
-                return .none
-            case .pairRows:
-                return .none
-            }
-        }
+        EmptyReducer()
         .forEach(\.pairRows, action: \.pairRows) {
             PairRowFeature()
         }
     }
 
+}
+
+// MARK: - Helpers
+
+extension DaySectionFeature.State.DayDate {
+    var title: String {
+        switch self {
+        case .continuousDate(let date, let weekNumber):
+            return String(localized: "screen.schedule.day.title.\(date.formatted(.scheduleDay)).\(weekNumber)")
+        case .weekday(let weekday):
+            @Dependency(\.calendar) var calendar
+            return weekday.localizedName(in: calendar).capitalized
+        case .examDate(let date):
+            return date?.formatted(.examDay) ?? "-/-"
+        }
+    }
+
+    func subtitle(for now: Date) -> String? {
+        switch self {
+        case .continuousDate(let date, _):
+            Self.relativeFormatter.relativeName(for: date, now: now)
+        case .weekday:
+            nil
+        case .examDate(let date):
+            date.flatMap { Self.relativeFormatter.relativeName(for: $0, now: now) }
+        }
+    }
+
+    func relativity(for now: Date) -> DaySectionFeature.State.Relativity {
+        switch self {
+        case .continuousDate(let date, let weekNumber):
+            relativity(for: date, now: now)
+        case .weekday(let weekday):
+            .future
+        case .examDate(let date):
+            date.map { relativity(for: $0, now: now) } ?? .future
+        }
+    }
+
+    private func relativity(for date: Date, now: Date) -> DaySectionFeature.State.Relativity {
+        @Dependency(\.calendar) var calendar
+        if calendar.isDate(date, inSameDayAs: now) {
+            return .today
+        } else if date < now {
+            return .past
+        } else {
+            return .future
+        }
+    }
+
     private static let relativeFormatter = RelativeDateTimeFormatter.relativeNameOnly()
 }

Modules/Sources/ScheduleFeature/Schedule/Day/DaySectionView.swift

@@ -4,6 +4,9 @@ import ComposableArchitecture
 
 struct DaySectionView: View {
     let store: StoreOf<DaySectionFeature>
+    @State var title: String = ""
+    @State var subtitle: String? = nil
+    @State var relativity: ScheduleDateTitle.Relativity = .upcoming
 
     var body: some View {
         WithPerceptionTracking {
@@ -16,16 +19,25 @@ struct DaySectionView: View {
                     content: { PairRowView(store: $0) }
                 )
                 .transformEnvironment(\.pairFilteringMode) { mode in
-                    if store.relativity == .past { mode = .filter }
+                    // Filter all pairs in passed section
+                    if relativity == .passed { mode = .filter }
                 }
             } header:{
                 ScheduleDateTitle(
-                    date: store.title,
-                    relativeDate: store.subtitle,
-                    relativity: ScheduleDateTitle.Relativity(store.relativity)
+                    date: title,
+                    relativeDate: subtitle,
+                    relativity: relativity
                 )
                 .transaction { $0.animation = nil }
-                .onAppear { store.send(.onAppear) }
+                .onAppear {
+                    // This data is dynamic and depends on `.now` value
+                    // We should recalculate it every time view appears
+                    // It is intentionally moved to view layer to prevent
+                    // spamming store with `onAppear` events too often
+                    title = store.dayDate.title
+                    subtitle = store.dayDate.subtitle(for: .now)
+                    relativity = ScheduleDateTitle.Relativity(store.dayDate.relativity(for: .now))
+                }
             }
         }
     }

Modules/Sources/ScheduleFeature/Schedule/List/ScheduleListView.swift

@@ -44,13 +44,9 @@ private struct ScheduleContentListView: View {
                     }
                 }
 
-                ForEach(
-                    store.scope(
-                        state: \.days,
-                        action: \.days
-                    ),
-                    content: DaySectionView.init
-                )
+                ForEach(store.scope(state: \.days, action: \.days)) { store in
+                    DaySectionView(store: store)
+                }
 
                 switch store.loading {
                 case .loadMore: