"src/modules/todo/observables" | todomvc-typescript-react-rxjs

Index

Type aliases

Variables

Functions

Type aliases

Id

Id<T>: function

Type parameters

Type declaration

- (id: T): T
- Parameters
  - id: T
  Returns T

Variables

_newTodoOperation$

_newTodoOperation$: Observable<object | object | object>

Private Const events$

events$: Subject<object | object | object | object> = new Subject<TodoEvent>()

getNewTodoOperation

getNewTodoOperation: function

Type declaration

- (): T
- Returns T

Const handleEvents$

handleEvents$: Observable<never> = events$.pipe(groupBy(event => {if (isFetchEvent(event)) {return EventType.Fetch;} else {return event.todo.id;}},event => event,actionsByGroup$ =>actionsByGroup$.pipe(timeoutWith(15000, EMPTY),ignoreElements())),mergeMap(groupedEvent$ =>groupedEvent$.pipe(switchMap(event => {if (isFetchEvent(event)) {return handleReadEvent(event);} else if (isEditEvent(event)) {return handleEditEvent(event);} else if (isSaveEvent(event)) {return handleSaveEvent(event);}return handleDeleteEvent(event);}))),ignoreElements())

handleEvents$ :: Observable ()

Main observable for handling incoming events that have been dispatched to the events$ Subject. Kind of like a reducer in redux.

It groups the events by type EventType.Fetch or the id of the Todo. and uses switchMap for each group.

Private Const newTodoOperation$

newTodoOperation$: StateObservable<NewTodoOperation> = thruple(_newTodoOperation$.pipe(switchMap(state =>isPending(state)? from(create(state)).pipe(tap(runCreateOutcomeEffect(writeTodos)),map(nextState => (isBad(nextState) ? nextState : makeNoop(""))),startWith(state)): of(state))),setNewTodoOperation,getNewTodoOperation)

setNewTodoOperation

setNewTodoOperation: function

Type declaration

- (next: T): void
- Parameters
  - next: T
  Returns void

todos$

writeTodos

writeTodos: function

Type declaration

- (next: T): void
- Parameters
  - next: T
  Returns void

Functions

Const dispatch

dispatch(event: TodoEvent): void

- Defined in src/modules/todo/observables.ts:91
```
dispatch :: TodoEvent -> ()
```
Function for dispatching to the events$ Subject
Parameters
- event: TodoEvent
  
  An EditEvent, SaveEvent, or DeleteEvent.
Returns void

Const dispatchFetch

dispatchFetch(): void

- Defined in src/modules/todo/observables.ts:103
```
dispatchFetch :: () -> void
```
Dispatches the FetchEvent to the events$ Subject.
Returns void

Const handleDeleteEvent

handleDeleteEvent(event: DeleteEvent): Observable<Transactional<TodoWithOperation | [RedoableEvent, ResetableOperation]>>

- Defined in src/modules/todo/observables.ts:231
Handle incoming events requesting Todo(s) be deleted from the database.

State is updating first to indicate "in progress". Then the API for deleting Todos is called. Once the call re solves state is updated to indicate failure or success. After a second state is updated once again to reset the operation so that the UI removes the indicators of failure or success.

Parameters
- event: DeleteEvent
  
  The delete event DeleteEvent
Returns Observable<Transactional<TodoWithOperation | [RedoableEvent, ResetableOperation]>>

Const handleEditEvent

handleEditEvent(event: EditEvent): Observable<unknown>

- Defined in src/modules/todo/observables.ts:268
```
handleEditEvent :: EditEvent -> Observable
```
Responsds to the EditEvent dispatched on the events$ Subject after the user types to change the title of a Todo

The only effect here is updating state. No API calls
Parameters
- event: EditEvent
  
  EditEvent
Returns Observable<unknown>

Const handleReadEvent

handleReadEvent(event: FetchEvent): Observable<Transactional<TodoWithOperation>>

- Defined in src/modules/todo/observables.ts:202
```
handleReadEvent :: FetchEvent -> Observable (Transactional TodoWithOperation)
```
Handles incoming FetchEvent events that have been dispatched to the events$ Subject

It immediately calls the API for requesting Todos from the server and updates state with the received todos by running the addEffect
Parameters
- event: FetchEvent
  
  The FetchEvent event
Returns Observable<Transactional<TodoWithOperation>>

Const handleSaveEvent

handleSaveEvent(event: SaveEvent): Observable<unknown>

- Defined in src/modules/todo/observables.ts:292
```
handleSaveEvent :: SaveEvent -> Observable ?
```
Handles incoming SaveEvent events that have been dispatched to [[event$]]
- It first updates state to indicate the Todo is currently being saved.
- Then calls the update API for mutating existing todos in the database.
- Passes the results to runSaveOutcomeEffect to update state with the updated Todo and TodoOperation
- The todo's operation is resets after a delay using the resetOkAndBadTodos operator
Parameters
- event: SaveEvent
Returns Observable<unknown>

Const resetOkAndBadTodos

resetOkAndBadTodos(updateOrDeleteEventAndOperation$: Observable<[RedoableEvent, ResetableOperation]>): Observable<[RedoableEvent, ResetableOperation]>

- Defined in src/modules/todo/observables.ts:130
```
resetOkAndBadTodos :: Observable (RedoableEvent, ResetableOperation) -> Observable (RedoableEvent, ResetableOperation)
```
Operator for resetting a Todo's TodoOperation to Noop after it was set to Bad or Ok
Parameters
- updateOrDeleteEventAndOperation$: Observable<[RedoableEvent, ResetableOperation]>
Returns Observable<[RedoableEvent, ResetableOperation]>

Index

Type aliases

Variables

Functions

Type aliases

Id

Type parameters

T

Type declaration

Parameters

id: T

Returns T

Variables

_newTodoOperation$

Private Const events$

getNewTodoOperation

Type declaration

Returns T

Const handleEvents$

Private Const newTodoOperation$

setNewTodoOperation

Type declaration

Parameters

next: T

Returns void

todos$

writeTodos

Type declaration

Parameters

next: T

Returns void

Functions

Const dispatch

Parameters

event: TodoEvent

Returns void

Const dispatchFetch

Returns void

Const handleDeleteEvent

Parameters

event: DeleteEvent

Returns Observable<Transactional<TodoWithOperation | [RedoableEvent, ResetableOperation]>>

Const handleEditEvent

Parameters

event: EditEvent

Returns Observable<unknown>

Const handleReadEvent

Parameters

event: FetchEvent

Returns Observable<Transactional<TodoWithOperation>>

Const handleSaveEvent

Parameters

event: SaveEvent

Returns Observable<unknown>

Const resetOkAndBadTodos

Parameters

updateOrDeleteEventAndOperation$: Observable<[RedoableEvent, ResetableOperation]>

Returns Observable<[RedoableEvent, ResetableOperation]>