How to properly write types for an array of generic React components and their properties?

Question

I'm trying to properly type the following scenario:

I have a manager/service that contains a collection of items, each item itself consisting of a React component and it's Props.
A method on the manager class takes a Component and the Props as parameters and adds it to the collection.
A third component subscribes to the collection and renders each component with it's props.
Each component that is to be added to the collection have some common properties including some that have generic types.

The code (without types to simply convey the idea) is something like this:

// ModalService.ts
class ModalService {
  modals = [];

  addModal(component, props) {
    this.modals.push({ component, props });
  }
}

// ModalManager.tsx
const ModalManager = () => {
  const modalService = useInjector(ModalService); // our custom DI injector

  return (
    
      {modalService.modals.forEach(({ Component, props }) => {
        
      })}
    
  )
}

// AboutModal.tsx
const AboutModal = (props) => {
  return (
    
      Hi {props.name}, welcome to this bizarre example

      
    
  )
}

// RandomNumber.tsx
const RandomNumberModal = (props) => {
  const randomNum = Math.round(Math.random() * (props.max - props.min)) + props.min;

  return (
    
      Today's random number is: {randomNum}

      
    
  )
}

// elsewhere in the app.tsx?
modalService.addModal(AboutModal, { 
  show: false, 
  onHide: () => void 
})

modalService.addModal(RandomNumberModal, {
  show: true,
  onHide: (num) => saveResult(num),
  min: 500,
  max: 1000
})

The problem I'm stuck with is coming up with properly typed definitions for the ModalService members when TypeScript is running strict mode. Right now, my types look like this:

interface SharedModalProps {
  show: boolean;
  onHide?: (result: TResult) => void;
}

interface AboutModalProps extends SharedModalProps {
  name: string;
}

interface RandomNumberModalProps extends SharedModalProps {
  min: number;
  max: number;
}

interface ModalItem {
  // cant use ComponentType> here because the type parameter for
  // TResult can be anything here
  // Ideally, I should be able to do something like ComponentType> or something similar
  Component: React.ComponentType;
  props: ComponentProps;
}

export type ModalsArray = ModalItem[];

export type AddModalFn = (
  component: TModal,
  props: React.ComponentProps
) => void;

With this configuration, the compiler complains about the modal components being passed to the addModal(component, props) function being incompatible with the defined type.

If I disable strict mode in tsconfig.json, then this error goes away and the correct types are resolved for the props parameter and completions for them work as well. But disabling Strict mode isn't really a solution.

What would be the correct way to type these components and the service so the compiler is able to infer the correct types and the editor is able to offer proper completions etc. as well?

I have this sample code up and running in a Code Sandbox here for reference.

user_13201937 · Answer

Try this type. All errors now shown

export default class ModalManagerService {
  @observable
  modals: ModalItem[] = [];

  addModal>(Component: TModal & React.ComponentType, props: TProps) {
    this.modals.push({ Component, props });

    // expect props to have the shared types from SharedModalProps
  }
}

I use this for reference: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router/index.d.ts

user_1868008 · Answer

If you don't need to keep track of the props, you could just store wrappers of the components you need to render instead of storing the component and props separately.

Service

interface ModalItem {
  Component: React.ComponentType;
}
...
  addModal(Component: React.ComponentType) {
    this.modals.push({ Component });
  }
...

App

...
          service.addModal(() => (
             console.log('test')} />
          ));
...

ModalManager

      {managerService.modals.map(({ Component }, index) => {
        return ;
      })}

user_1074135 · Answer

here is your code with types, it validates that you pass the correct props as well. You can do the same with interfaces if you prefer them. and link to ts playground.

type ModalProps = {
  show: boolean,
  onHide: (val: T) => void
}

class ModalService {
  modals: Array<{Component:React.FunctionComponent, props: ModalProps}> = [];

  addModal>(Component: React.FunctionComponent, props: T) {
    this.modals.push({ Component, props });
  }
}

const modalService = useInjector(ModalService); // our custom DI injector

const ModalManager = () => {
  return (
    
      {modalService.modals.map(({ Component, props }) => {
        return 
      })}
    
  )
}

const AboutModal = (props: {name: string} & ModalProps) => {
  return (
    
      Hi {props.name}, welcome to this bizarre example

      
    
  )
}

const RandomNumberModal = (props: {max: number, min: number} & ModalProps) => {
  const randomNum = Math.round(Math.random() * (props.max - props.min)) + props.min;

  return (
    
      Today's random number is: {randomNum}

      
    
  )
}

modalService.addModal(AboutModal, { 
  onHide: () => {},
  show: false,
  name: 'asdf',
});

function useInjector(Service: typeof ModalService) {
  return new Service();
}

user_4718434 · Answer

you can install @types/react as dependency in codesandbox.
after that, your mentioned error appears. (sandbox)
the errors says the type of AboutModal is FC (a functional component with props of type AboutModalProps), but it's not assignable to type React.ComponentType<{}> (a react component with unspecified prop types).
one way is to accept any prop types in your component:

// CHANGE:
Component: React.ComponentType
// TO:
Component: React.ComponentType // accept component with any props

With adding (as component props), the component accepts the props of type AboutModalProps and the error is gone. (sandbox)

Now, we can replace any with a more specific type like allModalProps:

export interface allModalProps extends SharedModalProps {
  // put all of the possible modal props here.
  name: string;
  min: number;
  max: number;
}

Now let's use the above declaration instead of React.ComponentType:

Component: React.ComponentType // replaced any with allModalProps

This way, we defined a modal props interface, and we used this interface as component props, instead of any. and we have no type errors.

Here is the sandbox: Sandbox

How to properly write types for an array of generic React components and their properties?

4 Answers