Mary Rose Cook's notebook

The public parts of my notebook.

My homepage.

Simple React patterns, Lucas Reis

• Simple React Patterns | Lucas Reis' Blog

Loading data cleanliness

• All code that loads data should include a loading state and an error state.

Solo render function pattern

const PlanetView = ({ name, climate, terrain }) => (
  <div>
    <h2>{name}</h2>
    <div>Climate: {climate}</div>
    <div>Terrain: {terrain}</div>
  </div>
);

• Super succinct way of expressing a view that is just a render method.

Patterns for when the model code doesn't need to be reused

Mixed component pattern

• Contains view, view logic and model.

export default class Dagobah extends React.Component {
  state = { loading: true };

  componentDidMount() {
    fetch("https://swapi.co/api/planets/5")
      .then(res => res.json())
      .then(
        planet => this.setState({ loading: false, planet }),
        error => this.setState({ loading: false, error })
      );
  }

  renderLoading() {
    return <div>Loading...</div>;
  }

  renderError() {
    return <div>I'm sorry! Please try again.</div>;
  }

  renderPlanet() {
    const { name, climate, terrain } = this.state.planet;
    return (
      <div>
        <h2>{name}</h2>
        <div>Climate: {climate}</div>
        <div>Terrain: {terrain}</div>
      </div>
    );
  }

  render() {
    if (this.state.loading) {
      return this.renderLoading();
    } else if (this.state.planet) {
      return this.renderPlanet();
    } else {
      return this.renderError();
    }
  }
}

• Downsides.
  • The presence of model code means testing the view code is harder than it needs to be. In this example, in order to test the error and loaded view layouts, you need to either have data fetching work in the testing environment, or mock the data request.
  • Harder to change model code because it's polluted with the view.
  • Harder to decompose view if it grows because it's polluted with the model.

Container/view pattern

class PlanetView extends React.Component {
  renderLoading() {
    return <div>Loading...</div>;
  }

  renderError() {
    return <div>I'm sorry! Please try again.</div>;
  }

  renderPlanet() {
    const { name, climate, terrain } = this.props.planet;
    return (
      <div>
        <h2>{name}</h2>
        <div>Climate: {climate}</div>
        <div>Terrain: {terrain}</div>
      </div>
    );
  }

  render() {
    if (this.props.loading) {
      return this.renderLoading();
    } else if (this.props.planet) {
      return this.renderPlanet();
    } else {
      return this.renderError();
    }
  }
}

class DagobahContainer extends React.Component {
  state = { loading: true };

  componentDidMount() {
    fetch("https://swapi.co/api/planets/5")
      .then(res => res.json())
      .then(
        planet => this.setState({ loading: false, planet }),
        error => this.setState({ loading: false, error })
      );
  }

  render() {
    return <PlanetView {...this.state} />;
  }
}

export default DagobahContainer;

• Luis tries to use this pattern as much as possible.
• Interesting that these are still in the same file.
• Passes state of container as props for view.

Container/branch/view pattern

const LoadingView = () => <div>Loading...</div>;

const ErrorView = () => <div>Please try again.</div>;

const PlanetView = ({ name, climate, terrain }) => (
  <div>
    <h2>{name}</h2>
    <div>Climate: {climate}</div>
    <div>Terrain: {terrain}</div>
  </div>
);

const PlanetBranch = ({ loading, planet }) => {
  if (loading) {
    return <LoadingView />;
  } else if (planet) {
    return <PlanetView {...planet} />;
  } else {
    return <ErrorView />;
  }
};

class DagobahContainer extends React.Component {
  state = { loading: true };

  componentDidMount() {
    fetch("https://swapi.co/api/planets/5")
      .then(res => res.json())
      .then(
        planet => this.setState({ loading: false, planet }),
        error => this.setState({ loading: false, error })
      );
  }

  render() {
    return <PlanetBranch {...this.state} />;
  }
}

export default DagobahContainer;

• Breaks the view into the view logic (branch) and view.
• Isolates the views further.

Patterns for when the view needs to be decoupled from the model

Higher order component pattern

const withDagobah = PlanetViewComponent =>
  class extends React.Component {
    state = { loading: true };

    componentDidMount() {
      fetch("https://swapi.co/api/planets/5")
        .then(res => res.json())
        .then(
          planet => this.setState({ loading: false, planet }),
          error => this.setState({ loading: false, error })
        );
    }

    render() {
      return <PlanetViewComponent {...this.state} />;
    }
  };

export default withDagobah(PlanetBranch);

• No longer hardcodes the view that will display the planet.
• Downside: parameter names (loading, error, planet - the "shape") of model and view must match exactly. You sometimes find yourself writing a special component to transform from one to another.
• Note that if the sub component doesn't need to be passed any props, it's easier to use the children construct (Google it).
• Why don't you just make the container a normal component and pass in the view as a prop? Because in order to render the view, you need to use some a slightly clunky API called cloneElement that I found not very readable.

• Can also curry this pattern:

const hoc = withPlanet('tatooine')(PlanetView);

Render props pattern (AKA Children as function pattern)

class Dagobah extends React.Component {
  state = { loading: true };

  componentDidMount() {
    fetch("https://swapi.co/api/planets/5")
      .then(res => res.json())
      .then(
        planet => this.setState({ loading: false, planet }),
        error => this.setState({ loading: false, error })
      );
  }

  render() {
    return this.props.render(this.state);
  }
}

export default () => (
  <Dagobah
    render={({ loading, error, planet }) => {
      if (loading) {
        return <LoadingView />;
      } else if (planet) {
        return <PlanetView {...planet} />;
      } else {
        return <ErrorView />;
      }
    }}
  />
);

• An alternative to higher order component pattern. Instead of currying in a component to a helper with function, passes in a render function directly to the model component. No particular advantage, besides succinctness.

Context

• Context - React docs
• Context is a feature of React. It lets you define data in a parent component that is automatically available to of the components children. It doesn't need to be passed down as props.
• It is used to allow a parent component to supply data to a descendent several layers down.
• The React docs says Context should be avoided unless absolutely necessary.
  • Prefer using props to pass the data down through the hierarchy.
  • Prefer Redux.

Provider pattern

import React from "react";
import PropTypes from "prop-types";

const contextTypes = {
  dagobah: PropTypes.shape({
    loading: PropTypes.bool,
    error: PropTypes.object,
    planet: PropTypes.shape({
      name: PropTypes.string,
      climate: PropTypes.string,
      terrain: PropTypes.string
    })
  })
};

// provider

export class DagobahProvider extends React.Component {
  state = { loading: true };

  componentDidMount() {
    fetch("https://swapi.co/api/planets/5")
      .then(res => res.json())
      .then(
        planet => this.setState({ loading: false, planet }),
        error => this.setState({ loading: false, error })
      );
  }

  static childContextTypes = contextTypes;

  getChildContext() {
    return { dagobah: this.state };
  }

  render() {
    return this.props.children;
  }
}

// higher order component

const withDagobah = PlanetViewComponent =>
  class extends React.Component {
    static contextTypes = contextTypes;

    render() {
      const { props, context } = this;
      return <PlanetViewComponent {...props} {...context.dagobah} />;
    }
  };

const DagobahPlanet = withDagobah(PlanetView);

• It's bad form to make a component descend directly from a provider. It means the context is implicit. Better is to use a higher order component or render props as above to make the context explicit.

#medianotes #notebook