Day 14 · 2부 · 레거시 읽기와 14일 총정리

// 1.7 이전 스타일 — State에 @ObservableState가 없고, 뷰는 ViewStore를 거친다
@Reducer
struct Profile {
  struct State: Equatable {
    var firstName = ""
    var lastName = ""
    @BindingState var nickname = ""        // 바인딩할 필드마다 표시
    @BindingState var isPublic = false
    var saveCount = 0
  }
  enum Action: BindableAction {
    case binding(BindingAction<State>)
    case saveButtonTapped
  }
  var body: some ReducerOf<Self> {
    BindingReducer()
    Reduce { state, action in
      switch action {
      case .binding:
        return .none
      case .saveButtonTapped:
        state.saveCount += 1
        return .none
      }
    }
  }
}

struct ProfileView: View {
  let store: StoreOf<Profile>

  struct ViewState: Equatable {            // 뷰가 볼 상태를 손으로 고른다
    let fullName: String
    @BindingViewState var nickname: String
    @BindingViewState var isPublic: Bool
    init(store: BindingViewStore<Profile.State>) {
      fullName = "\(store.firstName) \(store.lastName)"
      _nickname = store.$nickname
      _isPublic = store.$isPublic
    }
  }

  var body: some View {
    WithViewStore(store, observe: ViewState.init) { viewStore in
      Form {
        Text(viewStore.fullName)
        TextField("닉네임", text: viewStore.$nickname)
        Toggle("공개", isOn: viewStore.$isPublic)
        Button("저장") { viewStore.send(.saveButtonTapped) }
      }
    }
  }
}

@Reducer
struct Profile {
  @ObservableState                          // ① 추가
  struct State: Equatable {
    var firstName = ""
    var lastName = ""
    var nickname = ""                       // ② @BindingState 삭제
    var isPublic = false
    var saveCount = 0
    var fullName: String { "\(firstName) \(lastName)" }   // ③ ViewState의 계산값은 State로
  }
  enum Action: BindableAction {             // BindableAction · BindingReducer는 남긴다
    case binding(BindingAction<State>)
    case saveButtonTapped
  }
  var body: some ReducerOf<Self> {
    BindingReducer()
    Reduce { state, action in
      switch action {
      case .binding:
        return .none
      case .saveButtonTapped:
        state.saveCount += 1
        return .none
      }
    }
  }
}

struct ProfileView: View {
  @Bindable var store: StoreOf<Profile>     // ④ 바인딩이 필요하면 @Bindable

  var body: some View {                     // ⑤ WithViewStore·ViewState 삭제
    Form {
      Text(store.fullName)
      TextField("닉네임", text: $store.nickname)
      Toggle("공개", isOn: $store.isPublic)
      Button("저장") { store.send(.saveButtonTapped) }
    }
  }
}

// 아래 두 버전이 함께 쓰는 자식 기능
@Reducer
struct Row {
  @ObservableState
  struct State: Equatable, Identifiable { let id: Int; var title = "" }
  enum Action { case tapped }
  var body: some ReducerOf<Self> { Reduce { _, _ in .none } }
}

@Reducer
struct Editor {
  @ObservableState
  struct State: Equatable { var text = "" }
  enum Action { case saveButtonTapped }
  var body: some ReducerOf<Self> { Reduce { _, _ in .none } }
}

struct RowView: View {
  let store: StoreOf<Row>
  var body: some View { Text(store.title) }
}

struct EditorView: View {
  let store: StoreOf<Editor>
  var body: some View { Text(store.text) }
}

@Reducer
struct Inbox {
  struct State: Equatable {
    var banner: Row.State?
    var rows: IdentifiedArrayOf<Row.State> = []
    @PresentationState var editor: Editor.State?
    @PresentationState var alert: AlertState<Action.Alert>?
  }
  enum Action {
    case alert(PresentationAction<Alert>)
    case banner(Row.Action)
    case editor(PresentationAction<Editor.Action>)
    case rows(IdentifiedActionOf<Row>)
    enum Alert: Equatable { case confirmDelete }
  }
  var body: some ReducerOf<Self> {
    Reduce { _, _ in .none }
      .ifLet(\.banner, action: \.banner) { Row() }
      .forEach(\.rows, action: \.rows) { Row() }
      .ifLet(\.$editor, action: \.editor) { Editor() }
      .ifLet(\.$alert, action: \.alert)
  }
}

struct InboxView: View {
  let store: StoreOf<Inbox>

  var body: some View {
    List {
      IfLetStore(store.scope(state: \.banner, action: \.banner)) { bannerStore in
        RowView(store: bannerStore)
      }
      ForEachStore(store.scope(state: \.rows, action: \.rows)) { rowStore in
        RowView(store: rowStore)
      }
    }
    .sheet(store: store.scope(state: \.$editor, action: \.editor)) { editorStore in
      EditorView(store: editorStore)
    }
    .alert(store: store.scope(state: \.$alert, action: \.alert))
  }
}

@Reducer
struct Inbox {
  @ObservableState
  struct State: Equatable {
    var banner: Row.State?
    var rows: IdentifiedArrayOf<Row.State> = []
    @Presents var editor: Editor.State?           // @PresentationState → @Presents
    @Presents var alert: AlertState<Action.Alert>?
  }
  enum Action {
    case alert(PresentationAction<Alert>)
    case banner(Row.Action)
    case editor(PresentationAction<Editor.Action>)
    case rows(IdentifiedActionOf<Row>)
    enum Alert: Equatable { case confirmDelete }
  }
  var body: some ReducerOf<Self> {                 // 리듀서 쪽은 한 글자도 안 바뀐다
    Reduce { _, _ in .none }
      .ifLet(\.banner, action: \.banner) { Row() }
      .forEach(\.rows, action: \.rows) { Row() }
      .ifLet(\.$editor, action: \.editor) { Editor() }
      .ifLet(\.$alert, action: \.alert)
  }
}

struct InboxView: View {
  @Bindable var store: StoreOf<Inbox>

  var body: some View {
    List {
      if let bannerStore = store.scope(\.banner, action: \.banner) {   // IfLetStore → if let
        RowView(store: bannerStore)
      }
      ForEach(store.scope(\.rows, action: \.rows)) { rowStore in       // ForEachStore → ForEach
        RowView(store: rowStore)
      }
    }
    .sheet(item: $store.scope(\.editor, action: \.editor)) { editorStore in   // \.$editor 아님
      EditorView(store: editorStore)
    }
    .alert($store.scope(\.alert, action: \.alert))
  }
}

@Reducer
struct Tabs {
  struct State: Equatable { var tab = 0 }
  enum Action { case tabChanged(Int) }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .tabChanged(tab):
        state.tab = tab
        return .none
      }
    }
  }
}

struct TabsView: View {
  let store: StoreOf<Tabs>
  var body: some View {
    WithViewStore(store, observe: { $0 }) { viewStore in
      TabView(selection: viewStore.binding(get: \.tab, send: { .tabChanged($0) })) {
        Text("홈").tag(0)
        Text("설정").tag(1)
      }
    }
  }
}

@Reducer
struct Tabs {
  @ObservableState
  struct State: Equatable { var tab = 0 }
  enum Action { case tabChanged(Int) }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .tabChanged(tab):
        state.tab = tab
        return .none
      }
    }
  }
}

struct TabsView: View {
  @Bindable var store: StoreOf<Tabs>
  var body: some View {
    TabView(selection: $store.tab.sending(\.tabChanged)) {   // 읽기는 tab, 쓰기는 액션으로
      Text("홈").tag(0)
      Text("설정").tag(1)
    }
  }
}

// 시작 코드 (옛 API · 1.26.2에서 경고와 함께 컴파일된다)
@Reducer
struct Tally {
  struct State: Equatable {
    var count = 0
    @PresentationState var alert: AlertState<Action.Alert>?
  }
  enum Action {
    case alert(PresentationAction<Alert>)
    case incrementButtonTapped
    enum Alert: Equatable {}
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .alert:
        return .none
      case .incrementButtonTapped:
        state.count += 1
        if state.count == 3 {
          state.alert = AlertState { TextState("3번 눌렀다") }
        }
        return .none
      }
    }
    .ifLet(\.$alert, action: \.alert)
  }
}

struct TallyView: View {
  let store: StoreOf<Tally>
  var body: some View {
    WithViewStore(store, observe: \.count) { viewStore in
      VStack {
        Text("\(viewStore.state)")
        Button("+") { viewStore.send(.incrementButtonTapped) }
      }
      .alert(store: store.scope(state: \.$alert, action: \.alert))
    }
  }
}