react-is 19.2.8: isSuspenseList

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.isSuspenseList in pkg:npm/react-is@19.2.8
Kind: HOW

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

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:bbc4d3e4ac52c433fae26108350233a7a27a4405f072fe97afb12cd7c6b72699","contract":["isSuspenseList returns true for valid React 19 SuspenseList elements with Symbol.for('react.transitional.element')","isSuspenseList returns false for standard DOM element objects, Suspense elements, and Fragment elements","isSuspenseList returns false for plain objects, null, undefined, and primitives","isSuspenseList returns false for the raw SuspenseList symbol when not wrapped in an element","isSuspenseList returns false for legacy React 18 element objects using Symbol.for('react.element')","typeOf returns SuspenseList symbol for valid React 19 SuspenseList elements"],"goal":"verify react-is.isSuspenseList in pkg:npm/react-is@19.2.8","kind":"HOW","packages":["pkg:npm/react-is@19.2.8"],"schemaVersion":1,"symbols":["react-is.isSuspenseList"]},"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@19.2.8"],"schemaVersion":1,"subject":"pkg:npm/react-is@19.2.8","symbols":["react-is.isSuspenseList"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-react-is-is-suspense-list",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-react-is-is-suspense-list",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "react-is": "19.2.8"
      }
    },
    "node_modules/react-is": {
      "version": "19.2.8",
      "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.2.8.tgz",
      "integrity": "sha512-s5un28nYxKJw5gvUHyW5PCC28CvBqLu9r3cWgzHT4Vo/5fqqkFcdRYsGcKf50WMPpjjFZS5d76fn3YCo2njKwQ==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-react-is-is-suspense-list",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification of react-is.isSuspenseList in React 19",
  "type": "module",
  "main": "src/index.js",
  "license": "MIT-0",
  "dependencies": {
    "react-is": "19.2.8"
  }
}

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

import {
  SuspenseList,
  isSuspenseList,
  typeOf,
  Element,
} from 'react-is';

export { SuspenseList, isSuspenseList, typeOf, Element };

/**
 * Creates a React 19 element representation.
 *
 * @param {*} type - The element type.
 * @param {Object} [props={}] - Element properties.
 * @returns {Object} React element object.
 */
export function createElement(type, props = {}) {
  return {
    $$typeof: Element || Symbol.for('react.transitional.element'),
    type,
    props,
    key: null,
    ref: null,
  };
}

/**
 * Creates a React 19 SuspenseList element representation.
 *
 * @param {Object} [props={}] - Properties for SuspenseList.
 * @returns {Object} React SuspenseList element object.
 */
export function createSuspenseListElement(props = {}) {
  return createElement(SuspenseList, props);
}

/**
 * Checks whether a given object 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);
}

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

import assert from 'node:assert/strict';
import {
  SuspenseList,
  isSuspenseList,
  typeOf,
  Element,
  createElement,
  createSuspenseListElement,
  checkIsSuspenseList,
  inspectTypeOf,
} from '../src/index.js';
import reactIs from 'react-is';

// Contract 1: isSuspenseList returns true for valid React 19 SuspenseList elements with Symbol.for('react.transitional.element')
const suspenseListElement = createSuspenseListElement({ revealOrder: 'forwards', children: [] });
assert.equal(typeof isSuspenseList, 'function', 'isSuspenseList must be a function');
assert.equal(checkIsSuspenseList(suspenseListElement), true, 'SuspenseList element must be identified by checkIsSuspenseList');
assert.equal(isSuspenseList(suspenseListElement), true, 'SuspenseList element must be identified by isSuspenseList');
assert.equal(reactIs.isSuspenseList(suspenseListElement), true, 'SuspenseList element must be identified by reactIs.isSuspenseList');

const emptySuspenseList = createSuspenseListElement();
assert.equal(checkIsSuspenseList(emptySuspenseList), true, 'Empty SuspenseList element must be identified by checkIsSuspenseList');
assert.equal(isSuspenseList(emptySuspenseList), true, 'Empty SuspenseList element must be identified by isSuspenseList');

// Contract 2: isSuspenseList returns false for standard DOM element objects, Suspense elements, and Fragment elements
const divElement = createElement('div', { id: 'test' });
assert.equal(checkIsSuspenseList(divElement), false, 'DOM element must not be identified as SuspenseList');
assert.equal(isSuspenseList(divElement), false, 'DOM element must return false from isSuspenseList');

const suspenseElement = createElement(Symbol.for('react.suspense'), { fallback: null });
assert.equal(checkIsSuspenseList(suspenseElement), false, 'Suspense element must not be identified as SuspenseList');
assert.equal(isSuspenseList(suspenseElement), false, 'Suspense element must return false from isSuspenseList');

const fragmentElement = createElement(Symbol.for('react.fragment'));
assert.equal(checkIsSuspenseList(fragmentElement), false, 'Fragment element must not be identified as SuspenseList');
assert.equal(isSuspenseList(fragmentElement), false, 'Fragment element must return false from isSuspenseList');

// Contract 3: isSuspenseList returns false for plain objects, null, undefined, and primitives
assert.equal(checkIsSuspenseList(null), false, 'null must return false');
assert.equal(checkIsSuspenseList(undefined), false, 'undefined must return false');
assert.equal(checkIsSuspenseList({}), false, 'Plain object must return false');
assert.equal(checkIsSuspenseList({ type: SuspenseList }), false, 'Object without $$typeof must return false');
assert.equal(checkIsSuspenseList('suspense_list'), false, 'String must return false');
assert.equal(checkIsSuspenseList(123), false, 'Number must return false');
assert.equal(checkIsSuspenseList(true), false, 'Boolean must return false');
assert.equal(checkIsSuspenseList([]), false, 'Array must return false');

// Contract 4: isSuspenseList returns false for the raw SuspenseList symbol when not wrapped in an element
assert.equal(checkIsSuspenseList(SuspenseList), false, 'Raw SuspenseList symbol must return false');
assert.equal(isSuspenseList(SuspenseList), false, 'Raw SuspenseList symbol must return false from isSuspenseList');
assert.equal(checkIsSuspenseList(Symbol.for('react.suspense_list')), false, 'Raw symbol must return false');

// Contract 5: isSuspenseList returns false for legacy React 18 element objects using Symbol.for('react.element')
const legacySuspenseList = {
  $$typeof: Symbol.for('react.element'),
  type: SuspenseList,
  props: {},
  key: null,
  ref: null,
};
assert.equal(checkIsSuspenseList(legacySuspenseList), false, 'Legacy React element must not be identified as React 19 SuspenseList');
assert.equal(isSuspenseList(legacySuspenseList), false, 'Legacy React element must return false from isSuspenseList');

// Contract 6: typeOf returns SuspenseList symbol for valid React 19 SuspenseList elements
assert.equal(inspectTypeOf(suspenseListElement), SuspenseList, 'inspectTypeOf must return SuspenseList symbol for SuspenseList element');
assert.equal(typeOf(suspenseListElement), SuspenseList, 'typeOf must return SuspenseList symbol for SuspenseList element');
assert.equal(reactIs.typeOf(suspenseListElement), SuspenseList, 'reactIs.typeOf must return SuspenseList symbol for SuspenseList element');
assert.equal(inspectTypeOf(emptySuspenseList), SuspenseList, 'inspectTypeOf must return SuspenseList symbol for empty SuspenseList element');

assert.equal(inspectTypeOf(divElement), Element, 'inspectTypeOf must return Element for standard DOM element');
assert.equal(inspectTypeOf(null), undefined, 'inspectTypeOf must return undefined for null');
assert.equal(inspectTypeOf(undefined), undefined, 'inspectTypeOf must return undefined for undefined');
assert.equal(inspectTypeOf({}), undefined, 'inspectTypeOf must return undefined for plain object');
assert.equal(inspectTypeOf(SuspenseList), undefined, 'inspectTypeOf must return undefined for raw symbol');

console.log('All contract assertions for react-is.isSuspenseList in react-is@19.2.8 passed.');