Updated documentation

Author: StevenLambion

Guides/Composing Reducers.md

@@ -13,26 +13,26 @@ SwiftDux helps build SwiftUI-based applications around an [elm-like architecture
 
 ## State
 
-The state is a single, immutable structure acting as the single source of truth within the application.
+The state is an immutable structure acting as the single source of truth within the application.
 
 Below is an example of a todo app's state. It has a root `AppState` as well as an ordered list of `TodoState` objects.
 
 ```swift
 import SwiftDux
 
-struct AppState: StateTyoe {
+struct AppState: Equatable {
  todos: OrderedState<TodoItem>
 }
 
-struct TodoItem: IdentifiableState {
+struct TodoItem: Equatable, Identifiable {
  var id: String,
  var text: String
 }
 ```
 
 ## Actions
 
-An action is a description of how the state will change. They're typically dispatched from events in the application. This could be a user interacting with the application or a service API receiving updates. Swift's enum type is ideal for actions, but structs and classes could be used as well.
+An action is a dispatched event to mutate the application's state. Swift's enum type is ideal for actions, but structs and classes could be used as well.
 
 ```swift
 import SwiftDux
@@ -46,10 +46,7 @@ enum TodoAction: Action {
 
 ## Reducers
 
-A reducer consumes an action to produce a new state. The `Reducer` protocol has two primary methods to override:
-
-- `reduce(state:action:)` - For actions supported by the reducer.
-- `reduceNext(state:action:)` - Dispatches an action to any sub-reducers. This method is optional.
+A reducer consumes an action to produce a new state.
 
 ```swift
 final class TodosReducer: Reducer {
@@ -67,34 +64,18 @@ final class TodosReducer: Reducer {
  }
  return state
  }
-
 }
 ```
 
-Here's an example of a root reducer dispatching to a subreducer.
-
-```swift
-final class AppReducer: Reducer {
- let todosReducer = TodosReducer()
-
- func reduceNext(state: AppState, action: TodoAction) -> AppState {
- State(
- todos: todosReducer.reduceAny(state.todos, action)
- )
- }
-
-}
-```
-
-Reducers can also be combined together. This is useful when multiple root reducers are needed, such as two reducers from separate modules.
+Reducers can also be added together to form a composite reducer.
 
 ```swift
 let combinedReducer = AppReducer + NavigationReducer
 ```
 
 ## Store
 
-The store acts as the container of the state. It needs to be initialized with a default state and a root reducer. Then inject it into the application using the `provideStore(_:)` view modifier.
+The store manages the state and notifies the views of any updates.
 
 ```swift
 import SwiftDux
@@ -106,121 +87,63 @@ window.rootViewController = UIHostingController(
 )
 ```
 
-## Connectable View
+## ConnectableView
 
-The `ConnectableView` protocol provides a slice of the application state to your views using the functions `map(state:)` and `body(props:)`. The `@MappedDispatch` property wrapper injects an `ActionDispatcher` to send actions to the store.
+The `ConnectableView` protocol provides a slice of the application state to your views using the functions `map(state:)` or `map(state:binder:)`.
 
 ```swift
 struct TodosView: ConnectableView {
- @MappedDispatch() private var dispatch
+ struct Props: Equatable {
+ var todos: [TodoItem]
+ }
 
  func map(state: AppState) -> OrderedState<Todo>? {
- state.todos
+ Props(todos: state.todos)
  }
 
  func body(props: OrderedState<Todo>): some View {
  List {
  ForEach(todos) { todo in
  TodoItemRow(item: todo)
  }
- .onDelete { self.dispatch(TodoAction.removeTodos(at: $0)) }
- .onMove { self.dispatch(TodoAction.moveTodos(from: $0, to: $1)) }
  }
  }
 }
 ```
 
-The view can later be placed like any other.
-
-```swift
-struct RootView: View {
-
- var body: some View {
- TodosView()
- }
-}
-```
-
 ## ActionBinding<_>
 
-SwiftUI has a focus on two-way bindings that connect to a single value source. To support updates through actions, SwiftDux provides a convenient API in the `ConnectableView` protocol using an `ActionBinder` object. Use the `map(state:binder:)` method on the protocol as shown below. It provides a value to the text field and dispatches an action when the text value changes. It also binds a function to a dispatchable action.
+Using the `map(state:binder:)` method on the `ConnectableView` protocol to bind an action to the props object. It can also be used to bind an updatable state value
+with an action.
 
 ```swift
-struct LoginForm: View {
-
+struct TodosView: ConnectableView {
  struct Props: Equatable {
- @ActionBinding var email: String
- @ActionBinding var onSubmit: ()->()
+ var todos: [TodoItem]
+ @ActionBinding var newTodoText: String
+ @ActionBinding var addTodo: ()->()
  }
 
- func map(state: AppState, binder: ActionBinder) -> Props? {
+ func map(state: AppState, binder: ActionBinder) -> OrderedState<Todo>? {
  Props(
- email: binder.bind(state.loginForm.email) { 
- LoginFormAction.setEmail($0)
- },
- onSubmit: binder.bind(LoginFormAction.submit)
+ todos: state.todos,
+ newTodoText: binder.bind(state.newTodoText) { TodoAction.setNewTodoText($0) },
+ addTodo: binder.bind { TodoAction.addTodo() }
  )
  }
 
- func body(props: Props) -> some View {
- VStack {
- TextField("Email", text: $props.email)
- /* ... */
- Button(action: props.onSubmit) {
- Text("Submit")
+ func body(props: OrderedState<Todo>): some View {
+ List {
+ TextField("New Todo", text: props.$newTodoText, onCommit: props.addTodo) 
+ ForEach(todos) { todo in
+ TodoItemRow(item: todo)
  }
  }
  }
 }
 ```
-
-## Passing Data to a Connectable View
-In some cases, a connected view needs external information to map the state to its props, such as an identifier. Simply add any needed variables to your view and access them in the mapping function.
-
-```swift
-struct TodoDetailsView: ConnectableView {
- var id: String
-
- func map(state: TodoList) -> Todo? {
- state[id]
- }
-}
-
-// Somewhere else in the view hierarchy:
-
-TodoDetailsView(id: "123")
-```
-
-## Previewing Connected Views
-To preview a connected view by itself, you can provide a store that contains the parent state and reducer it maps from. This preview is based on a view in the Todo List Example project. Make sure to add `provideStore(_:)` after the connect method.
-
-```swift
-#if DEBUG
-public enum TodoRowContainer_Previews: PreviewProvider {
- static var store: Store<TodoList> {
- Store(
- state: TodoList(
- id: "1",
- name: "TodoList",
- todos: .init([
- Todo(id: "1", text: "Get milk")
- ])
- ),
- reducer: TodosReducer()
- )
- }
- 
- public static var previews: some View {
- TodoRowContainer(id: "1")
- .provideStore(store)
- }
- 
-}
-#endif
-```
-
 ## Action Plans
-An `ActionPlan` is a special kind of action that can be used to group other actions together or perform any kind of async logic.
+An `ActionPlan` is a special kind of action that can be used to group other actions together or perform any kind of async logic outside of a reducer.
 
 ```swift
 /// Dispatch multiple actions together synchronously:
@@ -234,7 +157,7 @@ let plan = ActionPlan<AppState> { store in
 /// Perform async operations:
 
 let plan = ActionPlan<AppState> { store in
- userLocationService.getLocation { location
+ userLocationService.getLocation { location in
  store.send(LocationAction.updateLocation(location))
  }
 }
@@ -253,51 +176,30 @@ let plan = ActionPlan<AppState> { store, completed in
 dispatch(plan)
 ```
 
-#
-
-## Query External Services
-Action plans can be used in conjunction with the `onAppear(dispatch:)` view modifier to connect to external data sources when a view appears. If the action plan returns a publisher, it will automatically cancel when the view disappears. Optionally, use `onAppear(dispatch:cancelOnDisappear:)` if the publisher should continue.
-
-Action plans can also subscribe to the store. This is useful when the query needs to be refreshed if the application state changes. Rather than imperatively handling this by re-sending the action plan, it can be done more declaratively within it.
-
-Here's an example of an action plan that queries for todos. It updates whenever the filter changes. It also debounces to reduce the amount of queries sent to the external services.
+## Previewing Connected Views
+To preview a connected view by itself use the `provideStore(_:)` method inside the preview.
 
 ```swift
-enum TodoListAction {
- ...
-}
-
-extension TodoListAction {
-
- static func getState(from store: Store<AppState>) -> some Publisher {
- Just(store.state).merge(with: store.didChange.map { store.state })
- }
-
- static func queryTodos() -> ActionPlan<AppState> {
- ActionPlan<AppState> { store, completed in
- getState(from: store)
- .map { $0.filterBy }
- .removeDuplicates()
- .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
- .flatMap { filter in self.services.queryTodos(filter: filter) }
- .catch { _ in Just<[TodoItem]>([]) }
- .map { todos -> Action in TodoListAction.setTodos(todos) }
- .send(to: store, receivedCompletion: completed)
- }
- }
-}
-
-struct TodoListView: ConnectableView {
-
- func map(state: AppState) -> [TodoItem]? {
- state.todoList.items
+#if DEBUG
+public enum TodoRowContainer_Previews: PreviewProvider {
+ static var store: Store<TodoList> {
+ Store(
+ state: TodoList(
+ id: "1",
+ name: "TodoList",
+ todos: .init([
+ Todo(id: "1", text: "Get milk")
+ ])
+ ),
+ reducer: TodosReducer()
+ )
  }
-
- func body(props: [TodoItem]) -> some View {
- renderTodos(todos: props)
- .onAppear(dispatch: TodoListAction.queryTodos())
+ 
+ public static var previews: some View {
+ TodoRowContainer(id: "1")
+ .provideStore(store)
  }
-
- // ...
+ 
 }
+#endif
 ```

Guides/Getting Started.md

@@ -2,7 +2,7 @@
 
 ## Xcode
 
-Use the new swift package manager integration to include the library.
+Search for SwiftDux in Xcode's Swift Package Manager integration.
 
 ## Package.swift
 
@@ -13,7 +13,7 @@ import PackageDescription
 
 let package = Package(
  dependencies: [
- .Package(url: "https://github.com/StevenLambion/SwiftDux.git", majorVersion: 1, minor: 3)
+ .Package(url: "https://github.com/StevenLambion/SwiftDux.git", from: "2.0.0")
  ]
 )
 ```