React 18 typescript problem
  • 31-May-2023
Lightrun Team
Author Lightrun Team
React 18 typescript problem

React 18 typescript problem

Lightrun Team
Lightrun Team

Explanation of the problem

In React version 18, there have been tightened typing restrictions, leading to TypeScript errors in the project. Specifically, there are errors related to the usage of the components Saturation and Hue within JSX:

TS2786: 'Saturation' cannot be used as a JSX component.
<e>   Its instance type 'Saturation' is not a valid JSX element.
<e>     The types returned by 'render()' are incompatible between these types.
<e>       Type 'import("/node_modules/@types/react-dom/node_modules/@types/react/index").ReactNode' is not assignable to type 'React.ReactNode'.

TS2786: 'Hue' cannot be used as a JSX component.
<e>   Its instance type 'Hue' is not a valid JSX element.
<e>     The types returned by 'render()' are incompatible between these types.
<e>       Type 'import("/node_modules/@types/react-dom/node_modules/@types/react/index").ReactNode' is not assignable to type 'React.ReactNode'.

These errors indicate that the types returned by the render() function of the Saturation and Hue components are incompatible with the expected type React.ReactNode. The specific error message mentions a type mismatch between import("/node_modules/@types/react-dom/node_modules/@types/react/index").ReactNode and React.ReactNode.

Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for React 18 typescript problem

To resolve these TypeScript errors, it is necessary to address the type incompatibility and ensure that the Saturation and Hue components are used correctly within JSX elements.

import React from 'react';
import { Saturation, Hue } from 'react-color';

const MyComponent = () => {
  return (
      <Saturation /> {/* TypeScript error: 'Saturation' cannot be used as a JSX component */}
      <Hue /> {/* TypeScript error: 'Hue' cannot be used as a JSX component */}

The next step is to investigate the specific typings and declarations of the Saturation and Hue components to identify any changes required to make them compatible with React v18’s tightened typing restrictions.


Other popular problems with react-color

Problem: Incompatible Typings in React v18

One common issue encountered when using the react-color library is the presence of incompatible typings when upgrading to React version 18. This issue manifests as TypeScript errors related to type incompatibilities when using components from the react-color library. These errors typically indicate that the types returned by the components’ render() function are not compatible with the expected ReactNode type.


To resolve this problem, it is necessary to update the typings of the affected components to align with the tightened typing restrictions introduced in React v18. This may involve updating the type annotations within the react-color library or utilizing type definitions that are compatible with the new version of React. It is recommended to refer to the documentation or community resources of the react-color library for guidance on resolving the specific type incompatibilities and ensuring the proper usage of the components within JSX.

Problem: Styling Challenges

Another common challenge when using the react-color library is styling customization. While the library provides out-of-the-box color pickers and components, customizing the appearance of these components to match the desired design can be non-trivial. The default styling of the react-color components may not always align with the overall styling or theme of the application, requiring additional effort to achieve the desired visual integration.


To address styling challenges, developers can leverage various techniques such as CSS overrides or the use of CSS-in-JS libraries like styled-components or emotion. By applying custom styles to the react-color components, it is possible to achieve the desired visual integration and ensure a consistent look and feel across the application. Additionally, exploring the documentation or community resources of the react-color library may provide insights, examples, or third-party packages that assist in customizing the appearance of the components.

Problem: Limited Customization Options

While the react-color library offers a range of pre-built color pickers and components, it may have limitations when it comes to extensive customization or meeting specific requirements. These limitations can include a lack of certain features, customization options, or the inability to tailor the behavior of the components to match specific use cases.


When faced with limited customization options in the react-color library, developers have several alternatives. They can consider extending or creating custom components based on the existing ones provided by the library. This approach allows for more control and flexibility in meeting specific requirements. Alternatively, exploring other color picker libraries or leveraging lower-level color manipulation libraries in conjunction with react-color can offer more customization possibilities. Assessing the project’s specific needs and evaluating different libraries or approaches can help identify the most suitable solution for achieving the desired customization and behavior.

A brief introduction to react-color

The react-color library is a popular package in the React ecosystem that provides a collection of color pickers and components for building interactive color selection functionality in web applications. It offers a variety of pre-built components, including color sliders, swatches, and pickers, which can be easily integrated into React projects. The library is designed to simplify the process of working with colors in web applications by providing a set of reusable React components with built-in color handling and manipulation capabilities.

With react-color, developers can implement features such as color selection, color palette creation, and color manipulation in their React applications. The library supports a wide range of color formats, including RGB, HSL, HSV, and HEX, allowing for flexibility in color representation. It also provides event handlers and callbacks for capturing color changes, making it easy to incorporate color functionality into interactive user interfaces. The modular architecture of react-color enables developers to select and utilize only the components they need, reducing unnecessary dependencies and keeping the bundle size optimized.

Additionally, react-color offers customization options to match the visual design and styling of the application. It provides CSS classes and styles that can be overridden or extended, allowing developers to tailor the appearance of the color components to their specific requirements. The library is well-documented, with comprehensive API documentation and examples, making it easier for developers to understand and utilize its features effectively. Overall, react-color is a valuable tool for implementing color-related functionality in React applications, offering a rich set of components and flexibility for handling and manipulating colors.


Most popular use cases for react-color

  1. Color Selection and Manipulation: The react-color library is primarily used for implementing color selection and manipulation functionality in React applications. It provides a wide range of pre-built components, such as color pickers, sliders, swatches, and palettes, that allow users to choose and manipulate colors. Developers can integrate these components into their applications to enable users to select colors, adjust color values (e.g., RGB, HSL, HSV), and preview color changes in real-time.
  2. Color Palette Generation: Another common use case for react-color is generating color palettes. The library offers components and utilities to create color palettes based on various color models and algorithms. Developers can utilize the provided components, such as CompactPicker or SwatchesPicker, to allow users to select colors from a predefined palette or generate custom color palettes. Additionally, react-color provides utilities like color conversion functions, color scheme generation, and harmonization algorithms to assist in creating visually pleasing and harmonious color palettes.
  3. Customization and Integration: react-color offers customization options to adapt its components to fit the specific visual style and requirements of an application. Developers can customize the appearance of color components by overriding CSS classes or styles, allowing for seamless integration with the application’s design. The library also supports internationalization (i18n) and accessibility (a11y) features, making it easier to provide a localized and inclusive color selection experience. Furthermore, react-color can be easily integrated into larger React projects or component libraries, providing a convenient solution for incorporating color functionality into complex UI systems.

It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications. It’s a registration form away.

Get Lightrun

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.