React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

RxJS is a library for composing asynchronous and event-based programs by using observable sequences. 


rxjs

Recompose is a React utility belt for function components and higher-order components. Think of it like lodash for React.

recompose

***Note: Active maintenance for Recompose has been discontinued since the announcement for React hooks. Your existing code using Recompose will still work. Recompose is not compatible with RxJS version 6 and beyond. You can read more about the decision [here.](https://github.com/acdlite/recompose/issues/756#issuecomment-438674573)*** 


Loading data and handling events almost always introduces layers of complexity into React apps. Recompose and RxJS solve your async problems by using Streams to output components. This course walks you through combining the powers of React and RxJS to stream data into JSX with streaming patterns and pure React components.

Recompose provides helper functions to stream props using an Observable library of your choice into React. This lesson shows you how to configure Recompose to use RxJS then create a Streaming Component with Recompose’s componentFromStream helper function.

Configure Recompose to Build React Components from RxJS Streams

When you declare your Component and Props in JSX, you can pass those props along to your [RxJS](/q/rxjs) stream. This is typically done using `switchMap` or `combineLatest` where you can grab from the props from your `props$` stream and push them into another stream.

Pass a React Prop to a Stream in RxJS

Loading data using RxJS is simple using `Observable.ajax`. This lesson shows you how to take the ajax response and pass it along the stream to use as props in a React Component.

Stream a React Component from an Ajax Request with RxJS

Events are the beginning of most every stream. Recompose provides a `createEventHandler` function to help your create handler and stream pairs. Once the handler/stream pairs are created, it’s simply a matter of passing the handlers down the stream as props and combining the streams any way you want.

Handle React Events as Streams with RxJS and Recompose

Combining input streams then using `scan` to track the results is a common scenario when coding with streams. This lesson walks you through setting up two buttons and merging their input events together to build a streaming Counter component.

Merge RxJS Button Event Streams to Build a React Counter Component

You can decouple the parent stream Component from the mapped React Component by using `props.children` instead. This process involves mapping the stream to React’s `cloneElement` with the `children` then passing the `props` in manually.

Stream Props to React Children with RxJS

Mapping the props to multiple children involves the use of React’s `Children.map` so that you can map over each child Component provided to the Parent Component stream. Inside the mapping function, you use the `cloneElement` and pass the props manually as you would with a single child component.

Stream Props to Multiple Children with React's Children.map  and RxJS

Rather than using Components to push streams into other Components, `mapPropsStream` allows you to create functions that can wrap components to create shareable behaviors across components.

Create Stream Behaviors to Push Props in React Components with mapPropsStream

Functions created with `mapPropsStream` canned be composed together to build up powerful streams. Bring in the `compose` helper from Recompose then simply list your functions in the order you want the props to push through.

Compose Streams of React Props with Recompose’s compose and RxJS

If you hard-code a stream of props to target a specific prop, it becomes impossible to reuse that stream with any other components. Configuring your props stream with lenses will allow you to reuse your stream with any React component.

Make Reusable React Props Streams with Lenses

Kent taught us about the concept of "render props" in his lesson from the Advanced React Component Patterns course here: [https://egghead.io/lessons/react-use-render-props-with-react](https://egghead.io/lessons/react-use-render-props-with-react)

This lesson takes the concept of render props and migrates it over to streaming props by keeping the same example and simple refactoring the `Toggle` component which handles the render prop.

Build React Components from Streams with RxJS and Recompose

John Lindquist

Course Content