react-is 18.3.1: react-is

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify react-is in pkg:npm/react-is@18.3.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/react-is@18.3.1
Demonstrate these symbols/APIs:
  - react-is

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:37e3d65ae18ad7b155253493b407ae4fe5ec745814e0fb102e8e44096c03673c","contract":["isElement identifies valid React element objects and rejects primitives and empty objects","isValidElementType validates built-in HTML tag names, custom tags, component functions, classes, and React symbols","isFragment detects React Fragment elements with react.fragment type","isForwardRef detects elements created with react.forward_ref component types","isMemo detects elements created with react.memo wrapped components","isContextConsumer detects React Context Consumer elements and typeOf returns ContextConsumer","isContextProvider detects React Context Provider elements and typeOf returns ContextProvider","isLazy detects React Lazy component elements and typeOf returns Lazy","isPortal detects React Portal objects and typeOf returns Portal","isProfiler detects React Profiler elements and typeOf returns Profiler","isStrictMode detects React StrictMode elements and typeOf returns StrictMode","isSuspense detects React Suspense elements and typeOf returns Suspense","isSuspenseList detects React SuspenseList elements and typeOf returns SuspenseList","typeOf and inspectTypeOf return corresponding React type symbols or undefined for non-elements"],"goal":"verify react-is in pkg:npm/react-is@18.3.1","kind":"HOW","packages":["pkg:npm/react-is@18.3.1"],"schemaVersion":1,"symbols":["react-is"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/react-is@18.3.1"],"schemaVersion":1,"subject":"pkg:npm/react-is@18.3.1","symbols":["react-is"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-react-is",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-react-is",
      "version": "1.0.0",
      "dependencies": {
        "react-is": "18.3.1"
      }
    },
    "node_modules/react-is": {
      "version": "18.3.1",
      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-react-is",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification of react-is type checking functions and React symbol types",
  "type": "module",
  "main": "src/index.js",
  "dependencies": {
    "react-is": "18.3.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify react-is in pkg:npm/react-is@18.3.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/react-is@18.3.1"
  ],
  "symbols": [
    "react-is"
  ]
}

import ReactIs from 'react-is';

const {
  ContextConsumer,
  ContextProvider,
  Element,
  ForwardRef,
  Fragment,
  Lazy,
  Memo,
  Portal,
  Profiler,
  StrictMode,
  Suspense,
  SuspenseList,
  isAsyncMode,
  isConcurrentMode,
  isContextConsumer,
  isContextProvider,
  isElement,
  isForwardRef,
  isFragment,
  isLazy,
  isMemo,
  isPortal,
  isProfiler,
  isStrictMode,
  isSuspense,
  isSuspenseList,
  isValidElementType,
  typeOf,
} = ReactIs;

/**
 * Check if the given value is a valid React element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a React element.
 */
export function checkIsElement(value) {
  return isElement(value);
}

/**
 * Check if the given value is a valid React element type.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a valid element type.
 */
export function checkIsValidElementType(value) {
  return isValidElementType(value);
}

/**
 * Check if the given value is a React Fragment element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a Fragment element.
 */
export function checkIsFragment(value) {
  return isFragment(value);
}

/**
 * Check if the given value is a React ForwardRef element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a ForwardRef element.
 */
export function checkIsForwardRef(value) {
  return isForwardRef(value);
}

/**
 * Check if the given value is a React Memo element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a Memo element.
 */
export function checkIsMemo(value) {
  return isMemo(value);
}

/**
 * Check if the given value is a React Lazy component element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a Lazy component element.
 */
export function checkIsLazy(value) {
  return isLazy(value);
}

/**
 * Check if the given value is a React Portal object.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a Portal object.
 */
export function checkIsPortal(value) {
  return isPortal(value);
}

/**
 * Check if the given value is a React Profiler element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a Profiler element.
 */
export function checkIsProfiler(value) {
  return isProfiler(value);
}

/**
 * Check if the given value is a React StrictMode element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a StrictMode element.
 */
export function checkIsStrictMode(value) {
  return isStrictMode(value);
}

/**
 * Check if the given value is a React Suspense element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a Suspense element.
 */
export function checkIsSuspense(value) {
  return isSuspense(value);
}

/**
 * Check if the given value is a React SuspenseList element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a SuspenseList element.
 */
export function checkIsSuspenseList(value) {
  return isSuspenseList(value);
}

/**
 * Check if the given value is a React Context Consumer element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a Context Consumer element.
 */
export function checkIsContextConsumer(value) {
  return isContextConsumer(value);
}

/**
 * Check if the given value is a React Context Provider element.
 *
 * @param {*} value - The value to test.
 * @returns {boolean} True if the value is a Context Provider element.
 */
export function checkIsContextProvider(value) {
  return isContextProvider(value);
}

/**
 * Identify the React element type symbol of a given object.
 *
 * @param {*} value - The React element or object to inspect.
 * @returns {symbol|undefined} The React symbol type or undefined.
 */
export function inspectTypeOf(value) {
  return typeOf(value);
}

export {
  ContextConsumer,
  ContextProvider,
  Element,
  ForwardRef,
  Fragment,
  Lazy,
  Memo,
  Portal,
  Profiler,
  StrictMode,
  Suspense,
  SuspenseList,
  isAsyncMode,
  isConcurrentMode,
  isContextConsumer,
  isContextProvider,
  isElement,
  isForwardRef,
  isFragment,
  isLazy,
  isMemo,
  isPortal,
  isProfiler,
  isStrictMode,
  isSuspense,
  isSuspenseList,
  isValidElementType,
  typeOf,
};

import assert from 'node:assert/strict';
import {
  checkIsElement,
  checkIsValidElementType,
  checkIsFragment,
  checkIsForwardRef,
  checkIsMemo,
  checkIsLazy,
  checkIsPortal,
  checkIsProfiler,
  checkIsStrictMode,
  checkIsSuspense,
  checkIsSuspenseList,
  checkIsContextConsumer,
  checkIsContextProvider,
  inspectTypeOf,
  isAsyncMode,
  isConcurrentMode,
  isContextConsumer,
  isContextProvider,
  isElement,
  isForwardRef,
  isFragment,
  isLazy,
  isMemo,
  isPortal,
  isProfiler,
  isStrictMode,
  isSuspense,
  isSuspenseList,
  isValidElementType,
  typeOf,
  ContextConsumer,
  ContextProvider,
  Element,
  ForwardRef,
  Fragment,
  Lazy,
  Memo,
  Portal,
  Profiler,
  StrictMode,
  Suspense,
  SuspenseList,
} from '../src/index.js';

// 1. Function exports verification
assert.equal(typeof isElement, 'function', 'isElement should be a function');
assert.equal(typeof isValidElementType, 'function', 'isValidElementType should be a function');
assert.equal(typeof isFragment, 'function', 'isFragment should be a function');
assert.equal(typeof isForwardRef, 'function', 'isForwardRef should be a function');
assert.equal(typeof isMemo, 'function', 'isMemo should be a function');
assert.equal(typeof isLazy, 'function', 'isLazy should be a function');
assert.equal(typeof isPortal, 'function', 'isPortal should be a function');
assert.equal(typeof isProfiler, 'function', 'isProfiler should be a function');
assert.equal(typeof isStrictMode, 'function', 'isStrictMode should be a function');
assert.equal(typeof isSuspense, 'function', 'isSuspense should be a function');
assert.equal(typeof isSuspenseList, 'function', 'isSuspenseList should be a function');
assert.equal(typeof isContextConsumer, 'function', 'isContextConsumer should be a function');
assert.equal(typeof isContextProvider, 'function', 'isContextProvider should be a function');
assert.equal(typeof isAsyncMode, 'function', 'isAsyncMode should be a function');
assert.equal(typeof isConcurrentMode, 'function', 'isConcurrentMode should be a function');
assert.equal(typeof typeOf, 'function', 'typeOf should be a function');

assert.equal(typeof checkIsElement, 'function', 'checkIsElement helper should be a function');
assert.equal(typeof checkIsValidElementType, 'function', 'checkIsValidElementType helper should be a function');
assert.equal(typeof checkIsFragment, 'function', 'checkIsFragment helper should be a function');
assert.equal(typeof checkIsForwardRef, 'function', 'checkIsForwardRef helper should be a function');
assert.equal(typeof checkIsMemo, 'function', 'checkIsMemo helper should be a function');
assert.equal(typeof checkIsLazy, 'function', 'checkIsLazy helper should be a function');
assert.equal(typeof checkIsPortal, 'function', 'checkIsPortal helper should be a function');
assert.equal(typeof checkIsProfiler, 'function', 'checkIsProfiler helper should be a function');
assert.equal(typeof checkIsStrictMode, 'function', 'checkIsStrictMode helper should be a function');
assert.equal(typeof checkIsSuspense, 'function', 'checkIsSuspense helper should be a function');
assert.equal(typeof checkIsSuspenseList, 'function', 'checkIsSuspenseList helper should be a function');
assert.equal(typeof checkIsContextConsumer, 'function', 'checkIsContextConsumer helper should be a function');
assert.equal(typeof checkIsContextProvider, 'function', 'checkIsContextProvider helper should be a function');
assert.equal(typeof inspectTypeOf, 'function', 'inspectTypeOf helper should be a function');

// 2. React symbols definition
const REACT_ELEMENT_TYPE = Symbol.for('react.element');
const REACT_PORTAL_TYPE = Symbol.for('react.portal');
const REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
const REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
const REACT_PROFILER_TYPE = Symbol.for('react.profiler');
const REACT_PROVIDER_TYPE = Symbol.for('react.provider');
const REACT_CONTEXT_TYPE = Symbol.for('react.context');
const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
const REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
const REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
const REACT_MEMO_TYPE = Symbol.for('react.memo');
const REACT_LAZY_TYPE = Symbol.for('react.lazy');

// 3. React Element identification
const plainElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: 'div',
  props: { className: 'sample-container' },
  key: null,
  ref: null,
};

assert.equal(isElement(plainElement), true, 'Valid React element must be identified by isElement');
assert.equal(checkIsElement(plainElement), true, 'checkIsElement helper must return true for valid element');
assert.equal(isElement({}), false, 'Empty object is not a React element');
assert.equal(isElement(null), false, 'null is not a React element');
assert.equal(isElement(undefined), false, 'undefined is not a React element');
assert.equal(isElement('div'), false, 'string is not a React element');
assert.equal(isElement(123), false, 'number is not a React element');
assert.equal(typeOf(plainElement), Element, 'typeOf(plainElement) must equal Element');

// 4. Valid Element Type identification
assert.equal(isValidElementType('div'), true, 'String tag names are valid element types');
assert.equal(isValidElementType('custom-tag'), true, 'Custom HTML tag names are valid element types');
assert.equal(isValidElementType(() => null), true, 'Function components are valid element types');
assert.equal(isValidElementType(class {}), true, 'Class components are valid element types');
assert.equal(isValidElementType(REACT_FRAGMENT_TYPE), true, 'Fragment symbol is a valid element type');
assert.equal(isValidElementType(REACT_STRICT_MODE_TYPE), true, 'StrictMode symbol is a valid element type');
assert.equal(isValidElementType(REACT_PROFILER_TYPE), true, 'Profiler symbol is a valid element type');
assert.equal(isValidElementType(REACT_SUSPENSE_TYPE), true, 'Suspense symbol is a valid element type');
assert.equal(isValidElementType(REACT_SUSPENSE_LIST_TYPE), true, 'SuspenseList symbol is a valid element type');
assert.equal(isValidElementType(123), false, 'Numbers are not valid element types');
assert.equal(isValidElementType(null), false, 'null is not a valid element type');
assert.equal(isValidElementType(undefined), false, 'undefined is not a valid element type');

// 5. Fragment element detection
const fragmentElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: REACT_FRAGMENT_TYPE,
  props: { children: [] },
  key: null,
  ref: null,
};
assert.equal(isFragment(fragmentElement), true, 'Fragment element must be identified by isFragment');
assert.equal(checkIsFragment(fragmentElement), true, 'checkIsFragment helper must return true');
assert.equal(isFragment(plainElement), false, 'div element is not a Fragment');
assert.equal(typeOf(fragmentElement), Fragment, 'typeOf(fragmentElement) must equal Fragment');

// 6. ForwardRef element detection
const forwardRefType = {
  $$typeof: REACT_FORWARD_REF_TYPE,
  render: (props, ref) => null,
};
const forwardRefElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: forwardRefType,
  props: {},
  key: null,
  ref: null,
};
assert.equal(isForwardRef(forwardRefElement), true, 'ForwardRef element must be identified by isForwardRef');
assert.equal(checkIsForwardRef(forwardRefElement), true, 'checkIsForwardRef helper must return true');
assert.equal(isForwardRef(plainElement), false, 'div element is not a ForwardRef');
assert.equal(typeOf(forwardRefElement), ForwardRef, 'typeOf(forwardRefElement) must equal ForwardRef');

// 7. Memo element detection
const memoType = {
  $$typeof: REACT_MEMO_TYPE,
  type: 'span',
  compare: null,
};
const memoElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: memoType,
  props: {},
  key: null,
  ref: null,
};
assert.equal(isMemo(memoElement), true, 'Memo element must be identified by isMemo');
assert.equal(checkIsMemo(memoElement), true, 'checkIsMemo helper must return true');
assert.equal(isMemo(plainElement), false, 'div element is not a Memo');
assert.equal(typeOf(memoElement), Memo, 'typeOf(memoElement) must equal Memo');

// 8. Context Consumer & Provider detection
const contextObject = {
  $$typeof: REACT_CONTEXT_TYPE,
  _context: null,
};
contextObject._context = contextObject;

const consumerElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: contextObject,
  props: { children: () => null },
  key: null,
  ref: null,
};
assert.equal(isContextConsumer(consumerElement), true, 'Context Consumer element must be detected');
assert.equal(checkIsContextConsumer(consumerElement), true, 'checkIsContextConsumer helper must return true');
assert.equal(isContextConsumer(plainElement), false, 'div element is not a Context Consumer');
assert.equal(typeOf(consumerElement), ContextConsumer, 'typeOf(consumerElement) must equal ContextConsumer');

const providerType = {
  $$typeof: REACT_PROVIDER_TYPE,
  _context: contextObject,
};
const providerElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: providerType,
  props: { value: 'context-val' },
  key: null,
  ref: null,
};
assert.equal(isContextProvider(providerElement), true, 'Context Provider element must be detected');
assert.equal(checkIsContextProvider(providerElement), true, 'checkIsContextProvider helper must return true');
assert.equal(isContextProvider(plainElement), false, 'div element is not a Context Provider');
assert.equal(typeOf(providerElement), ContextProvider, 'typeOf(providerElement) must equal ContextProvider');

// 9. Lazy component detection
const lazyComponentType = {
  $$typeof: REACT_LAZY_TYPE,
  _payload: {},
  _init: () => null,
};
const lazyElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: lazyComponentType,
  props: {},
  key: null,
  ref: null,
};
assert.equal(isLazy(lazyElement), true, 'Lazy component element must be detected by isLazy');
assert.equal(checkIsLazy(lazyElement), true, 'checkIsLazy helper must return true');
assert.equal(isLazy(plainElement), false, 'div element is not a Lazy component');
assert.equal(typeOf(lazyElement), Lazy, 'typeOf(lazyElement) must equal Lazy');

// 10. Portal detection
const portalObject = {
  $$typeof: REACT_PORTAL_TYPE,
  key: null,
  children: [],
  containerInfo: {},
  implementation: null,
};
assert.equal(isPortal(portalObject), true, 'Portal object must be detected by isPortal');
assert.equal(checkIsPortal(portalObject), true, 'checkIsPortal helper must return true');
assert.equal(isPortal(plainElement), false, 'plain element is not a Portal');
assert.equal(typeOf(portalObject), Portal, 'typeOf(portalObject) must equal Portal');

// 11. Profiler detection
const profilerElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: REACT_PROFILER_TYPE,
  props: { id: 'test-profiler', onRender: () => {} },
  key: null,
  ref: null,
};
assert.equal(isProfiler(profilerElement), true, 'Profiler element must be detected by isProfiler');
assert.equal(checkIsProfiler(profilerElement), true, 'checkIsProfiler helper must return true');
assert.equal(isProfiler(plainElement), false, 'plain element is not a Profiler');
assert.equal(typeOf(profilerElement), Profiler, 'typeOf(profilerElement) must equal Profiler');

// 12. StrictMode detection
const strictModeElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: REACT_STRICT_MODE_TYPE,
  props: { children: [] },
  key: null,
  ref: null,
};
assert.equal(isStrictMode(strictModeElement), true, 'StrictMode element must be detected by isStrictMode');
assert.equal(checkIsStrictMode(strictModeElement), true, 'checkIsStrictMode helper must return true');
assert.equal(isStrictMode(plainElement), false, 'plain element is not a StrictMode element');
assert.equal(typeOf(strictModeElement), StrictMode, 'typeOf(strictModeElement) must equal StrictMode');

// 13. Suspense detection
const suspenseElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: REACT_SUSPENSE_TYPE,
  props: { fallback: null, children: [] },
  key: null,
  ref: null,
};
assert.equal(isSuspense(suspenseElement), true, 'Suspense element must be detected by isSuspense');
assert.equal(checkIsSuspense(suspenseElement), true, 'checkIsSuspense helper must return true');
assert.equal(isSuspense(plainElement), false, 'plain element is not a Suspense element');
assert.equal(typeOf(suspenseElement), Suspense, 'typeOf(suspenseElement) must equal Suspense');

// 14. SuspenseList detection
const suspenseListElement = {
  $$typeof: REACT_ELEMENT_TYPE,
  type: REACT_SUSPENSE_LIST_TYPE,
  props: { children: [] },
  key: null,
  ref: null,
};
assert.equal(isSuspenseList(suspenseListElement), true, 'SuspenseList element must be detected by isSuspenseList');
assert.equal(checkIsSuspenseList(suspenseListElement), true, 'checkIsSuspenseList helper must return true');
assert.equal(isSuspenseList(plainElement), false, 'plain element is not a SuspenseList element');
assert.equal(typeOf(suspenseListElement), SuspenseList, 'typeOf(suspenseListElement) must equal SuspenseList');

// 15. Negative checks for typeOf and inspectTypeOf
assert.equal(inspectTypeOf(plainElement), Element, 'inspectTypeOf returns Element symbol for plain element');
assert.equal(inspectTypeOf({}), undefined, 'inspectTypeOf returns undefined for non-React object');
assert.equal(inspectTypeOf(null), undefined, 'inspectTypeOf returns undefined for null');
assert.equal(inspectTypeOf('test-str'), undefined, 'inspectTypeOf returns undefined for string');
assert.equal(inspectTypeOf(42), undefined, 'inspectTypeOf returns undefined for number');

console.log('Contract tests passed successfully.');