Here are some the critiques I got back from some readers:

• Having to import findByType for every component using sub-components is annoying

• It is hard to compose or extend a sub-component to handle specific cases

• It’s not the most readable

• We could easily put the wrong data within the sub-component, it is not aware about what we’re trying to render within it

While I agreed with all these statements, I couldn’t find an elegant way to address them without making the component difficult to use. However one day, one user from the Reactiflux community mentioned that using contexts would remove the necessity of using the findByType util within each sub-component; which obviously got me curious. Moreover, I was hearing a lot about the upcoming new Context API in React 16.3.0 and I thought that this would be a great way to start experimenting a bit with this new functionality.

Up until now, I’ve always thought contexts in React were hard to use, and it never felt natural to me to implement components using them except in some rare higher-order components. Plus it always fell in the category of “experimental API” so I’ve never had enough confidence in it to use it for a lot of production components.

The new API, however, takes a new approach to contexts and makes the feature more accessible. It is available in React 16.3.0, you can read a lot more about it and how to use it in this article. For the purpose of this post, I’ll just keep it short and explain the 3 main items that make up this new pattern:

• React.CreateContext: a function that returns an object with a Provider and a Consumer

• Provider: a component that accepts a value prop

• Consumer: a Function as Child component with the value from the Provider as a parameter

With these new items, we’ll see that it is possible to create a better sub-component pattern that answers all the flaws stated in the first part.

For this part, we’ll try to build the same Article component that we’ve built in my first post, but this time using contexts.

In order to achieve this, we’ll need to create an ArticleContext. This will give us an ArticleContext.Provider component that will be our main parent, which we’ll rename Article, and an ArticleContext.Consumer, which will help us build all the sub-components we need.

Let’s start this example by implementing a Title sub-component:

1
import React from 'react';
4
const ArticleContext = React.createContext();
9
    <ArticleContext.Consumer>
10
      {({ title, subtitle }) => (
11
        <div style={{ textAlign: 'center' }}>
13
          <div style={{ color: '#ccc' }}>
18
    </ArticleContext.Consumer>
23
const Article = (props) => {
25
    <ArticleContext.Provider {...props}>
27
    </ArticleContext.Provider>
33
export default Article;

The example above shows how we can leverage Consumers and Providers to obtain the same sub-component pattern as we had in the first example of my previous article. If you compare this code in the link with the code above, you can see that the latter feels way simpler. Indeed, thanks to the new Context API, there is no need to build and use the findByType util. Additionally, we don’t rely on the displayName or name property of the sub-component to know how to render them.

In the code below, we can see that the resulting Article component is much easier to use. Instead of passing children to the Title sub-component, we just need to pass them in the value prop of Article, which will make them available to every Consumer of the Article context (i.e. to every sub-component defined as a Consumer of this context).

1
import React, { Component } from 'react';
2
import Article from './Article';
4
class App extends Component {
8
        title: <h1>React sub-components with</h1>,
10
          <div>Lets make simpler and more flexible React components</div>
17
    const { value } = this.state;
19
      <Article value={value}>

Moreover, if we want to wrap Article.Title in another div or component, we can now do that as well. Given that the implementation of the findByType util in my first post was relying on the direct children of Article , sub-components were restricted to be direct children and nothing else, which is not the case with this new way of doing sub-components.

Note: You can see above that my value object passed to the provider is set to the parent’s state. This is to avoid creating a new object for value all the time which will trigger a re-render of Provider and all of the consumers. See https://reactjs.org/docs/context.html#caveats

Additionally, we can make the piece of code above look even better. By simply exporting the Title functional component in Article.js we can give up the <Article.Title/> notation and simply use instead <Title/>.

1
import React, { Component } from 'react';
2
import Article, { Title } from './Article';
4
class App extends Component {
8
        title: <h1>React sub-components with</h1>,
10
          <div>Lets make simpler and more flexible React components</div>
16
    const { value } = this.state;
18
      <Article value={value}>

This is purely aesthetic though, and I personally prefer the first implementation. It gives more context about where a given sub-component comes from and with which parent component it can be used, and also avoids duplicated name issues.

When showing this new pattern to some other developers who were familiar with using the one described in my first article I got one critique: it’s not possible to whitelist children anymore; anything can go within the parent component. While this new implementation is more flexible, the first one was able to restrict the children of a component to only its sub-components. There are multiple ways to fix this, but so far the only one I’ve explored is by using flow. I’ll detail the process in my next article.

In the code snippets below, you will find:

• The full Article component code and all its sub-components in Article.js

• An example App.js where you can see how we use the full component and sub-components

1
import React from 'react';
4
const ArticleContext = React.createContext();
9
    <ArticleContext.Consumer>
10
      {({ title, subtitle }) => (
11
        <div style={{ textAlign: 'center' }}>
13
          <div style={{ color: '#ccc' }}>
18
    </ArticleContext.Consumer>
22
const Metadata = () => {
24
    <ArticleContext.Consumer>
25
      {({ author, date }) => (
29
            justifyContent: 'space-between',
36
    </ArticleContext.Consumer>
40
const Content = () => {
42
    <ArticleContext.Consumer>
44
        <div style={{ width: '500px', margin: '0 auto' }}>{content}</div>
46
    </ArticleContext.Consumer>
51
const Article = (props) => {
53
    <ArticleContext.Provider {...props}>
55
    </ArticleContext.Provider>
60
Article.Metadata = Metadata;
61
Article.Content = Content;
63
export default Article;

1
import React, { Component } from 'react';
2
import Article from './Article';
5
  Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
8
class App extends Component {
12
        title: <h1>React sub-components with</h1>,
14
          <div>Lets make simpler and more flexible React components</div>
16
        author: 'Maxime Heckel',
17
        date: <i>April 2018</i>,
18
        content: <p>{text}</p>,
23
    const { value } = this.state;
25
      <Article value={value}>
28
        <div style={{ width: '500px', margin: '80px auto' }}>

If you feel like playing with this pattern I’ve made the example of this article available on Github here, you can set up the dockerized project using docker-compose build && docker-compose up, or just run yarn && yarn start if you want to run it directly on your machine.