What is the best practice for reusable AlertState?

[Ojas-Chimane]

I have the following alert code that I want to reuse across different stores. What is the best practice to refactor the alertState logic so that I don't end up with duplicate code?

state.alert = AlertState {
                    TextState("Login Expired")
                } actions: {
                    ButtonState(role: .cancel, action: .logoutUser) {
                        TextState("Proceed to Login Screen")
                    }
                } message: {
                    TextState("The device has been inactive for 30 mins, you will be logged out. Please log back in to continue working")
                }

Example Store

import ComposableArchitecture

@Reducer
public struct HomeStore {
    @Dependency(HomeService.self) var homeService
    
    @ObservableState
    public struct State: Equatable {
        @Presents var alert: AlertState<Action.Alert>?
        var pickerPerformance = PickerPerformance()
        public var requestInFlight = false
    }
    
    public enum Action {
        case alert(PresentationAction<Alert>)
        case delegate(Delegate)
        case fetchPickerPerformance
        case logoutButtonTapped
        case displayDeviceInactiveAlert
        
        case pickerPerformanceResponse(Result<PickerPerformance, Error>)
        
        public enum Alert {
            case logoutUser
        }
    }
    
    @CasePathable
    public enum Delegate {
      case clearCredentials
    }
    
    public var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
                
            case .logoutButtonTapped:
                return .send(.delegate(.clearCredentials))
                
            case .fetchPickerPerformance:
                state.requestInFlight = true
                return .run { send in
                    await send(.pickerPerformanceResponse(Result { try await self.homeService.pickerPerformance(PickerPerformanceRequest()) }))
                }
                
            case .pickerPerformanceResponse(.failure):
                state.requestInFlight = false
                state.alert = AlertState {
                    TextState("Invalid QR token scanned")
                } actions: {
                    ButtonState(role: .cancel, action: .logoutUser) {
                        TextState("Logout")
                            .foregroundColor(.red)
                    }
                } message: {
                    TextState("Please logout and scan a valid token to continue")
                }
                return .none
                
            case .pickerPerformanceResponse(.success(let response)):
                state.requestInFlight = false
                state.pickerPerformance = response
                return .none
                
            case .displayDeviceInactiveAlert:
                state.alert = AlertState {
                    TextState("Login Expired")
                } actions: {
                    ButtonState(role: .cancel, action: .logoutUser) {
                        TextState("Proceed to Login Screen")
                    }
                } message: {
                    TextState("The device has been inactive for 30 mins, you will be logged out. Please log back in to continue working")
                }
                return .none
                
            case .delegate(_):
                return .none
                
            case .alert(.presented(.logoutUser)):
                return .run { send in await send(.logoutButtonTapped) }
                
            case .alert:
                return .none
            }
        }
        .ifLet(\.$alert, action: \.alert)
    }
}

[stephencelis]

@Ojas-Chimane We typically like to extend the AlertState type with static properties/functions for reuse. A few examples in the repo with the following search:

https://github.com/search?q=repo%3Apointfreeco%2Fswift-composable-architecture+%22extension+AlertState+where%22&type=code