Swiftpack.co - skyofdwarf/rdxvm as Swift Package

Swiftpack.co is a collection of thousands of indexed Swift packages. Search packages.
See all packages published by skyofdwarf.
skyofdwarf/rdxvm 0.9.1
Redux like ViewModel?
⭐️ 1
🕓 3 weeks ago
.package(url: "https://github.com/skyofdwarf/rdxvm.git", from: "0.9.1")

RDXVM

CircleCI Version License Platform

RDXVM is another MVVM implementation inspired by Redux and ReactorKit.

Example

To run the example project, clone the repo, and run pod install from the Example directory first.

Requirements

  • Swift 5
  • iOS 9

Depencencies

  • RxCocoa (~> 6.0)
  • RxRelay (~> 6.0)
  • RxSwift (~> 6.0)

Installation

RDXVM is available through CocoaPods. To install it, simply add the following line to your Podfile:

pod 'RDXVM'

Usage

ViewModel needs custom types for action, mutation, event, and state to subclass and create an instance.

enum Action {
    case add(Int)
    case subtract(Int)
}
enum Mutation {
    case add(Int)
    case calculating(Bool)
}
enum Event {
    case notSupported
}
struct State {
    var sum = 0
    var calculating = false
}

You can subclass ViewModel with these types and must override react(action:state:) and reduce(mutation:state:) methods. In react(action:state:, you should return an observable of Reaction:

  • a mutation to mutate state as the result of an action
  • an event to notify some event to view
  • an error that is explicit/implicit thrown
  • an action that is mapped from another action.
class CalcViewModel: ViewModel<Action, Mutation, State, Event> {
    init(state: State = State()) {
        super.init(state: state)
    }

    override func react(action: Action, state: State) -> Observable<Reaction> {
        switch action {
        case .add(let num):
            return .of(.mutation(.calculating(true)),
                .mutation(.add(num)),
                .mutation(.calculating(false)))
        case .subtract:
            return .just(.event(.notSupported))
        }
    }

    override func reduce(mutation: Mutation, state: inout State) {
        switch mutation {
        case let .add(let num):
            state.sum += num
        case let .calculating(let calculating):
            state.calculating = calculating
        }
    }
}

let vm = CalcViewModel<Action, Mutation, Event, State>()

Send actions to ViewModel and get outputs(event, error, state) from ViewModel.

addButton.rx.tap.map { Action.add(3) }
    .bind(to: vm.action)
    .disposed(by: dbag)

vm.event
    .emit()
    .disposed(by: dbag)

vm.error
    .emit()
    .disposed(by: dbag)

vm.state
    .drive()
    .disposed(by: dbag)

You can get current value of the state or property of the state.

// current state itself
vm.$state

// current value of state's property
vm.$state.sum

// '$' can be omitted to get prperty value of the state.
vm.state.sum

You can apply the @Drived attribute to a property of state, so you can directly drive that property instead of the state itself.

struct State {
    @Drived var sum = 0
    @Drived var calculating = false
}

vm.state.$sum.drive()
vm.state.$calculating.drive()

Author

skyofdwarf, [email protected]

License

RDXVM is available under the MIT license. See the LICENSE file for more info.

GitHub

link
Stars: 1
Last commit: 3 weeks ago
jonrohan Something's broken? Yell at me @ptrpavlik. Praise and feedback (and money) is also welcome.

Dependencies

Swiftpack is being maintained by Petr Pavlik | @ptrpavlik | @swiftpackco | API | Analytics