If you really want to type check for

• component vs element

• class vs functional component

• DOM vs Composite Element

You could try something like this.

function isClassComponent(component) {
    return (
        typeof component === 'function' && 
        !!component.prototype.isReactComponent
    )
}

function isFunctionComponent(component) {
    return (
        typeof component === 'function' && 
        String(component).includes('return React.createElement')
    )
}

function isReactComponent(component) {
    return (
        isClassComponent(component) || 
        isFunctionComponent(component)
    )
}

function isElement(element) {
    return React.isValidElement(element);
}

function isDOMTypeElement(element) {
    return isElement(element) && typeof element.type === 'string';
}

function isCompositeTypeElement(element) {
    return isElement(element) && typeof element.type === 'function';
}

USE

// CLASS BASED COMPONENT
class Foo extends React.Component {
  render(){
      return <h1>Hello</h1>;
  }
}

const foo = <Foo />;

//FUNCTIONAL COMPONENT
function Bar (props) { return <h1>World</h1> }
const bar = <Bar />;

// REACT ELEMENT
const header = <h1>Title</h1>;

// CHECK
isReactComponent(Foo); // true
isClassComponent(Foo); // true
isFunctionComponent(Foo); // false
isElement(Foo); // false

isReactComponent(<Foo />) // false
isElement(<Foo />) // true
isDOMTypeElement(<Foo />) // false
isCompositeTypeElement(<Foo />) // true

isReactComponent(Bar); // true
isClassComponent(Bar); // false
isFunctionComponent(Bar); // true
isElement(Bar); // false

isReactComponent(<Bar />) // false
isElement(<Bar />) // true
isDOMTypeElement(<Bar />) // false
isCompositeTypeElement(<Bar />) // true

isReactComponent(header); // false
isElement(header); // true
isDOMTypeElement(header) // true
isCompositeTypeElement(header) // false

Example Codepen

The simplest solution is:

React.isValidElement(element)

In addition to @EmanualJade answer, you can use this to check if a variable is a function component

React.isValidElement(Component())

As @Leonardo has pointed out, some compilers can cause this to fail:

String(component).includes('return React.createElement')

This is an old question, with an old answer.

If you run into this issue, probably you'll want to check the react-is NPM package page: https://www.npmjs.com/package/react-is

It's an official React module that takes into account details like ref forwarding, and memo to check for an element type.

To check if a value is an element type do: ReactIs.isValidElementType(obj)

Checks if something is a React component or an Array of components:

// checks if the argument is a React component or an Array of components
const isReactComp = v => React.isValidElement(v) ||
    (
      Array.isArray(v) && 
      v.every(node => React.isValidElement(node))
    );

const Test = ({children}) => <div>{isReactComp(children) + ''}</div>;
const MemoedComp = React.memo(({children}) => children);

// Render 
ReactDOM.render(
  <div>
    <Test>hello</Test>
    <Test><i>hello</i></Test>
    <Test>{[<i key={1}>hello</i>]}</Test>
    <Test><MemoedComp>hello</MemoedComp></Test>
  </div>
, root)

<script src="https://cdnjs.cloudflare.com/ajax/libs/react/17.0.2/umd/react.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/17.0.2/umd/react-dom.production.min.js"></script>
<div id="root"></div>