app Crashes when get back

[knight6700]

when i get back with IFLEtStore and make a state with nil app crashes or get empty View
2023-01-27 16:05:32.056479+0200 Spomotion[15531:24441369] [ComposableArchitecture] An "ifLet" at "UserProfileMenu/PlacesProfileView.swift:163" received a child action when child state was "nil". …

Action:
PlaceProfile.Action.createVentAction(.createEventInfoState(.onAppear))

This is generally considered an application logic error, and can happen for a few reasons:

• A parent reducer set child state to "nil" before this reducer ran. This reducer must run before any other reducer sets child state to "nil". This ensures that child reducers can handle their actions while their state is still available.

• An in-flight effect emitted this action when child state was "nil". While it may be perfectly reasonable to ignore this action, consider canceling the associated effect before child state becomes "nil", especially if it is a long-living effect.

• This action was sent to the store while state was "nil". Make sure that actions for this reducer can only be sent from a view store when state is non-"nil". In SwiftUI applications, use "IfLetStore".
Swift/ContiguousArrayBuffer.swift:600: Fatal error: Index out of range
2023-01-27 16:05:32.087200+0200 Spomotion[15531:24441369] Swift/ContiguousArrayBuffer.swift:600: Fatal error: Index out of range

[stephencelis]

@knight6700 Can you share more code, e.g. what your state, action and reducer look like, and what the view looks like? Without code it'll be tough to diagnose the actual problem.

The warning that occurs before the crash may also contain a hint as to the issue. Did you give it a read?

An "ifLet" at "UserProfileMenu/PlacesProfileView.swift:163" received a child action when child state was "nil". …

Action:

PlaceProfile.Action.createVentAction(.createEventInfoState(.onAppear))

This is generally considered an application logic error, and can happen for a few reasons:

• A parent reducer set child state to "nil" before this reducer ran. This reducer must run before any other reducer sets child state to "nil". This ensures that child reducers can handle their actions while their state is still available.

• An in-flight effect emitted this action when child state was "nil". While it may be perfectly reasonable to ignore this action, consider canceling the associated effect before child state becomes "nil", especially if it is a long-living effect.

• This action was sent to the store while state was "nil". Make sure that actions for this reducer can only be sent from a view store when state is non-"nil". In SwiftUI applications, use "IfLetStore".

[knight6700]

in Reducer

public struct PlaceProfile: ReducerProtocol {
    public enum Destination: Int, Identifiable, Hashable {
        public var id: Int {
            rawValue
        }
        case createEvent
    }

    public struct State: Equatable {
        var mapState: MapPlace.State = .init(place: PlaceData.mock)
        var profile: PlaceData
        var alertAndConfirmationDialog = AlertAndConfirmationDialog.State()
        var createEventState: CreateEventFeature.State?
        var images: [Photo] {
            profile.photos
        }

        var imagesIsEmpty: Bool {
            images.isEmpty
        }

        var tags: [Tags] {
            [
                .init(id: 1,
                      name: profile.visibility.description,
                      visibility: profile.visibility),
                .init(id: 1,
                      name: profile.type.description,
                      type: profile.type)
            ]
        }

        var activities: [Tags] {
            profile.categoriesInfo.map { Tags(id: $0.id, name: $0.name) }
        }

        var currentSliderIndex = 0
        var spacing: CGFloat = .horizonSpacing(.xs)
        var padding: CGFloat = .horizonSpacing(.xs)
        var wordCount: Int = 75
        var alignmentIndex = 0
        let alignments: [HorizontalAlignment] = [.leading, .center, .trailing]

        var alignment: HorizontalAlignment {
            alignments[alignmentIndex]
        }

        public init(profile: PlaceData) {
            self.profile = profile
        }

        var name: String {
            profile.name 
        }

        var address: String {
            profile.address.formattedAddress
        }

        var coordinate: Coordinates {
            profile.address.coordinates
        }

        var isPrivate: Bool {
            profile.visibility == .private
        }

        var placeType: String {
            profile.type.description
        }

        var placeTypeImage: String {
            profile.type.rawValue
        }

        var website: String {
            profile.website ?? .empty
        }

        var selectedImage = ""
        var isShowImageScreen = false
        var categories: String {
            let count = profile.categoriesInfo.count
            guard count >= 1 else {
                return ""
            }
            let more = count == 1 ? "" : " +\(count)"
            return "\(profile.categoriesInfo[0].name)\(more)"
        }

        var showingOptions: Bool = false
        var screenSize: CGSize {
            UIScreen.main.bounds.size
        }
        var destination: Destination?
    }

    public enum Action: Equatable {
        case swipeImageSlider(Int)
        case popToRoot
        case back
        case tags([Tags])
        case mapAction(MapPlace.Action)
        case selectedImage(String)
        case showImageFullScreen(Bool)
        case openNavigation(Bool)
        case showOption(Bool)
        case alertAndConfirmationDialog(AlertAndConfirmationDialog.Action)
        case navigate(Destination?)
        case createVentAction(CreateEventFeature.Action)
    }

    public var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            switch action {
            case let .swipeImageSlider(currentIndex):
                state.currentSliderIndex = currentIndex
            case .popToRoot:
                break
            case .back:
                break
            case .tags:
                break
            case let .selectedImage(image):
                state.selectedImage = image
                return .none
            case let .showImageFullScreen(isShow):
                state.isShowImageScreen = isShow
                return .none
            case let .mapAction(action):
                switch action {
                case .onAppear:
                    state.mapState.place = state.profile
                    state.mapState.headerState?.description = state.profile.landmark ?? ""
                default:
                    break
                }
            case .openNavigation:
                return .none
            case let .showOption(isShowOption):
                state.showingOptions = isShowOption
            case .alertAndConfirmationDialog:
                return .none
            case let .navigate(destination):
                state.destination = destination
                guard  destination != nil else {
                    state.createEventState = nil
                    return .none
                    
                }
                state.createEventState = .init(createEventInfoState: .init(placeData: state.profile))
            case .createVentAction(.complete):
                return .run {
                    await $0.send(.navigate(nil))
                }
            case .createVentAction(_):
                return .none
            }
            return .none
        }
        .ifLet(\.createEventState,
                action: /Action.createVentAction
        ) {
            CreateEventFeature()
        }
        Scope(state: \.mapState, action: /Action.mapAction) {
            MapPlace()
                ._printChanges()
        }

        Scope(state: \.alertAndConfirmationDialog, action: /Action.alertAndConfirmationDialog) {
            AlertAndConfirmationDialog()
        }
    }

    public init() {}
}

in View

.navigationDestination(unwrapping: viewStore.binding(get:\.destination, send: PlaceProfile.Action.navigate), destination: { _ in
                    IfLetStore(
                        store.scope(
                            state: \.createEventState,
                            action: PlaceProfile.Action.createVentAction
                        ),
                        then: {CreateEventView(store: $0)}
                    )
                    }
                )