!CombineFeedbackModule.swift

import SwiftUI
import CombineFeedback
import CombineFeedbackUI

protocol Module: Loggable, Identifiable, StatefulProtocol, EventfulProtocol
where State: Identifiable, ID == State.ID, State.ID == UUID, Store.State == State, Store.Event == Event {
    associatedtype Store: CFUIStoreProtocol
    associatedtype Event
    associatedtype ContentView: ContextualView
    var store: Store { get }
    init(store: Store)
}

extension Module {
    var id: ID { store.state.id }
}

protocol ContextualView: View {
    associatedtype _Context: CFUIContextProtocol
    var context: _Context { get }
    init(context: _Context)
}

_Store.swift

import Combine
import CombineFeedback
import CombineFeedbackUI

typealias _Store<State, Event> = CombineFeedbackUI.Store<State, Event>

extension _Store {
    static func userInput(_ input: AnyPublisher<Event, Never>) -> Feedback<State, Event> {
        .middleware { _ in input }
    }
    
    func send(events: Event...) { send(events: events) }
    func send(events: [Event]) { events.forEach(send) }
}

CombineFeedbackProtocols.swift

import SwiftUI
import CombineFeedback
import CombineFeedbackUI

protocol StatefulProtocol {
    associatedtype State
}

protocol EventfulProtocol {
    associatedtype State
}

protocol CFUIStoreProtocol: StatefulProtocol, EventfulProtocol {
    associatedtype Event
    
    var state: State { get }
    func send(event: Event)
    func mutate<V>(keyPath: WritableKeyPath<State, V>, value: V)
}

protocol CFUIContextProtocol: ObservableObject, StatefulProtocol, EventfulProtocol {}

extension CombineFeedbackUI.Store: CFUIStoreProtocol {}
extension Context: CFUIContextProtocol {}

CombineFeedbackRouting.swift

import SwiftUI
import CombineFeedbackUI

extension View where Self: Identifiable, Self.ID == UUID {
    func onDismiss(perform action: (() -> Void)?) -> some View {
        Router.shared.onDismiss(of: id, perform: action)
        return self
    }
}

private class Router {
    fileprivate static let shared: Router = .init()
    
    private var handlers: [UUID: (() -> Void)?] = [:]
    
    fileprivate func dismiss(_ id: UUID) {
        let handler = handlers[id]
        handlers[id] = nil
        handler??()
    }
    
    fileprivate func onDismiss(of id: UUID, perform action: (() -> Void)?) {
        handlers[id] = action
    }
}

extension Context where State: Identifiable, State.ID == UUID {
    func dismiss() { Router.shared.dismiss(self.id) }
}

Dependencies:
CombineFeedback
LoggingKit

Example

Back to index