Index

A

• actions
  • using / It's time to take action, Enforcing the use of actions
  • about / Actions, Observable state and actions, Actions, The cycle of derivation
  • decorating / Decorating actions
  • async action, managing / Managing the async action
  • need for / Why an action?
  • async actions / Async actions
  • flow() function / flow()
• API layer / The API layer
• async-operations
  • visualizing, with fromPromise() / Visualizing async-operations with fromPromise()
• async actions / Async actions
• atoms
  • about / The Atom
  • reading, at runtime / Reading atoms at runtime
  • creating / Creating an Atom
  • atomic clock example / The atomic clock example
• autorun()
  • about / autorun()
  • configuring / Configuring autorun() and reaction()
  • options / Options for autorun()

B

• batch / The cycle of derivation
• book search / The book search
• boxed observables / Creating observables

C

• @computed
  • derived state / Derived state with @computed
  • about / There's more to computed()
  • properties / There's more to computed()
  • error handling / Error handling inside computed
• Cart checkout workflow
  • about / The Cart checkout workflow
  • route / A route for a step, a step for a route
  • WorkflowStep / The WorkflowStep
  • actions /  Actions and reactions of the workflow
  • reactions /  Actions and reactions of the workflow
  • step, loading / Loading a step
  • HistoryTracker / The HistoryTracker
• computed observable / The computed observable
• computed properties
  • about / The computed observable, Derivations (computed properties)
  • versus MobX reactions / Is it a side effect?
• ComputedValue
  • about / ComputedValue
  • computation / Efficient computation

D

• @decorators
  • used, for controlling observability / Using @decorators
• data, shapes
  • singular values / The shape of data
  • lists / The shape of data
  • hierarchy / The shape of data
  • composite / The shape of data
• declarative models
  • immutable snapshots / Immutable snapshots
  • JSON patches / JSON patches
  • middleware / Middlewares
• decorate() API
  • used, for creating observability / Using the decorate() API
• decorators / A note on observability
• derivation
  • about / The computed observable, Derivations (computed properties), Derivation
  • process / The cycle of derivation
  • exception handling / Exception handling
• derived state
  • with @computed / Derived state with @computed
  • about / Derivations (computed properties)
  • example / Derivations (computed properties)
  • side effect / Is it a side effect?
• developer experience (DX) / MobX versus Redux

E

• error handling
  • inside computed / Error handling inside computed
• Event Oriented Programming (EOP) / Value Oriented Programming

F

• fine-tuning primitive types / Fine-tuning primitive types
• flow() function / flow()
• form validation
  • about / Form validation
  • interactions / The interactions
  • observable state, modeling / Modeling the observable state
  • actions / Onto the actions
  • reactions / Completing the triad with reactions
  • React components / React components
• functional programming / It is functional...

H

• higher-order-component (HOC) / The Reactive UI

L

• layered architecture
  • about / A layered architecture
  • atoms / The Atom
  • atoms, creating / Creating an Atom
  • ObservableValue / ObservableValue
  • ComputedValue / ComputedValue
  • derivation / Derivation
  • API layer / The API layer
• lazyObservable()
  • using, for deferred updates / Using lazyObservable() for deferred updates
  • generalizing, with fromResource() / A generalized lazyObservable() with fromResource()
• lexical this / Observable state and actions

M

• Material-UI
  • reference / React components
• middlewares
  • about / Redux in a nutshell
  • URL / Middlewares
• MobX
  • versus Redux / MobX versus Redux
• mobx-react / A reactive UI
• mobx-react-form
  • reference / Other observer components
• mobx-state-tree
  • about / An opinionated MobX with mobx-state-tree
  • model / Models – properties, views, and actions
  • actions, defining on model / Defining actions on the model
  • derived information, creating with views / Creating derived information with views
  • fine-tuning primitive types / Fine-tuning primitive types
  • trees, composing / Composing trees
  • identifiers / References and identifiers
  • referencing, by types.identifier() / Referencing by types.identifier() and types.reference()
  • referencing, by types.reference() / Referencing by types.identifier() and types.reference()
  • declarative models, advantages / Out-of-the-box benefits of declarative models
• mobx-utils, utility functions
  • about / The utility functions of mobx-utils
  • async-operations, visualizing with fromPromise() / Visualizing async-operations with fromPromise()
  • lazyObservable(), using for deferred updates / Using lazyObservable() for deferred updates
  • view-model, used for managing edits / A view model to manage edits
  • exploring / There is lot more to discover
  • URL / There is lot more to discover
• MobX reactions
  • versus computed properties / Is it a side effect?
• MobX reactivity system
  • about / When does MobX react?
  • rules / The rules

O

• @observable.ref
  • reference-only observables, creating / Creating reference-only observables with @observable.ref
• @observable.shallow
  • shallow observables, creating / Creating shallow observables with @observable.shallow
• @observable.struct
  • structural observables, creating / Creating structural observables with @observable.struct
• object API
  • manipulation / Direct manipulation with the object API
  • granular reads / Granular reads and writes
  • granular writes / Granular reads and writes
  • MobX observables, converting to JavaScript / From MobX to JavaScript
• observability
  • controlling / Controlling observability
  • controlling, @decorators used / Using @decorators
  • creating, decorate() API used / Using the decorate() API
  • extending / Extending the observability
• observable() API
  • decorating with / Decorating with observable()
• observables
  • about / An observable state, Observables, ComputedValue
  • creating / Creating observables
  • arrays / Observable arrays
  • maps / Observable maps
  • working / A note on observability
  • computed observable / The computed observable
  • syntax, with decorators / Better syntax with decorators
  • event flow, reviewing / Watching the events flow by
  • hooking up / Hooking into the observability
  • temperature, lazy loading / Lazy loading the temperature
  • intercept() API, using / Gatekeeper of changes
  • change argument, intercepting / Intercepting the change
  • observe(), using / observe() the changes
• observable state / Observable state and actions
• ObservableValue / ObservableValue
• observer / Observing the state changes, ComputedValue
• observer components / Other observer components
• one-level-deep observation / Creating shallow observables with @observable.shallow
• opinionated MobX
  • with mobx-state-tree / An opinionated MobX with mobx-state-tree

P

• page routing
  • about / Page routing
  • Cart checkout workflow / The Cart checkout workflow
  • observable state, modeling / Modeling the observable state
  • React components / The React components

R

• React components
  • UserEnrollmentForm component / The UserEnrollmentForm component
  • TemplateStepComponent / The TemplateStepComponent
  • ShowCart component / The ShowCart component
  • state-based router / A state-based router
• reaction()
  • about / reaction()
  • reactive UI / A reactive UI
  • configuring / Configuring autorun() and reaction()
  • options / Options for reaction()
• reactions
  • about / Reactions, Reactions
  • autorun() / autorun()
  • reaction() / reaction()
  • when() / when()
  • overview / Quick recap on reactions
• reactive system
  • querying / Querying the reactive system
  • exploring / Probing deeper into the reactive system
• Reactive UI
  • about / The Reactive UI
  • store, connecting / Getting to the store
  • SearchTextField component / The SearchTextField component
  • ResultsList component / The ResultsList component
• reducers / Redux in a nutshell
• Redux
  • comparing, with state management / A comparison with Redux
  • overview / Redux in a nutshell
  • versus MobX / MobX versus Redux
• reference-only observables
  • creating, with @observable.ref / Creating reference-only observables with @observable.ref
• runInAction() function / Wrapping with runInAction()

S

• shallow observables
  • creating, with @observable.shallow / Creating shallow observables with @observable.shallow
• ShowCart component / The ShowCart component
• side effects / The side effect model
• single page apps (SPA) / Page routing
• Single Responsibility Principle (SRP) / The side effect model
• single state tree / A comparison with Redux
• state
  • changes, observing / Observing the state changes
• state-based routing solution
  • reference / A state-based router
• stateless functional component / A reactive UI
• state management
  • client state / The client state
  • about / The client state
  • changes, handling in state / Handling changes in state
  • side effect model / The side effect model
• stores
  • modeling / Modeling the stores
• strict mode / Enforcing the use of actions
• structural equality / Structural equality
• structural observables
  • creating, with @observable.struct / Creating structural observables with @observable.struct

T

• TemplateStepComponent / The TemplateStepComponent
• Transparent Functional Reactive Programming (TFRP)
  • about / Transparent functional reactive programming
  • transparent / It is Transparent...
  • reactive / It is reactive...
  • functional / It is functional...
  • URL / It is functional...
  • Value Oriented Programming (VOP) / Value Oriented Programming

U

• UserEnrollmentForm component / The UserEnrollmentForm component
• utilities
  • about / Development utilities
  • spy(), used for tracking reactivity / Using spy() to track the reactivity
  • reaction, tracing / Tracing a reaction
  • visual debugging, with mobx-react-devtools / Visual debugging with mobx-react-devtools

V

• Value Oriented Programming (VOP) / Value Oriented Programming

W

• when()
  • executing / when()
  • executing, with promise / when() with a promise
• WishListStore
  • observable state / Observable state
  • derived state / Derived state
  • actions / Actions