Carl Rippon

Building SPAs

Carl Rippon
BlogBooks / CoursesAbout
This site uses cookies. Click here to find out more

React Context with TypeScript: Part 1 - Simple context with function components

February 18, 2020

Photo by mohammad takhsh on Unsplash

React context allows several components in a tree to share some data. It’s more convenient than passing the data via props down the component tree. How can we use TypeScript to create a strongly-typed context? Is it possible to do this for use with function components as well as class components? This is the first of four blog posts that go through this topic.

In this post, we will create a strongly-typed React context and consume it in a function component that doesn’t doesn’t change the context.

Creating a context

A common use case for using context is to provide theme information to components in an app. We are going to provide a color value in a context that components can use.

Let’s start by creating our theme using Reacts createContext function:

const defaultTheme = "white";
const ThemeContext = React.createContext(

We are required to provide a default value for the context, which in our case is "white".

The type of the context is inferred to be React.Context<string>:

Inferred type for a simple context

Nice - exactly as we require!

Creating a Context provider

Next, we are going to create the provider component:

type Props = {
  children: React.ReactNode
export const ThemeProvider = ({
}: Props) => {
  const [theme, setTheme] = React.useState(

  React.useEffect(() => {
    // We'd get the theme from a web API / local storage in a real app
    // We've hardcoded the theme in our example
    const currentTheme = "lightblue";
  }, []);

  return (
    <ThemeContext.Provider value={theme}>

We hold the theme value in the state. This means that when it changes, React will automatically re-render the provider’s children with the new theme.

We get the current theme value using Reacts useEffect hook and update the theme state value.

Out theme provider component returns the Provider component within the context with our theme value. The provider is wrapped around all the children in the component tree.

Creating a custom hook for consuming the context

We can create a custom hook that will allow function components to consume our context:

export const useTheme = () =>

Let’s check what the return type of useTheme has been inferred as:

Inferred type for context hook

The return type of useTheme is string because this is the type of the context value.

Adding the provider to the component tree

The ThemeProvider component can now be placed in an appropriate position in the component tree.

const App = () => (
    <Header />

Components below it will have access to the context, but components above it won’t. So, the Header component will have access to the context.

Consuming the context

The Header component can access the context by using the useTheme hook we created. This allows the header component to render an element that has its background color set to the theme color:

const Header = () => {
  const theme = useTheme();
  return (
    <div style={{ backgroundColor: theme }}>

A working version of ThemeContext is available by clicking the link below. When the app is run, Hello will appear with a light blue background.

Open working version

Wrap up

The type for the context is inferred correctly if a sensible default is provided when it is created. If the context is providing values that consumers don’t change, then this is fine. However, what if we want the user to change the theme? In this case, our context would need to provide a function for updating the theme, and this can’t be provided as a default value. In the next post, we will extend our theme context so that consumers can update the value.

Did you find this post useful?

Let me know by sharing it on Twitter.
Click here to share this post on Twitter

If you to learn more about using TypeScript with React, you may find my course useful:

Using TypeScript with React

Using TypeScript with React
Find out more

Want more content like this?

Subscribe to receive notifications on new blog posts and courses

© Carl Rippon
Privacy Policy