react-is 18.3.1: isContextProvider

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.isContextProvider 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.isContextProvider

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:23cdafb9753a29aa317495fa53e0c6999b55cc3e0f801269b5ce41c876d56488","contract":["isContextProvider is exported as a function from react-is","isContextProvider returns true for React Context Provider element objects","isContextProvider returns false for React Context Consumer element objects","isContextProvider returns false for standard DOM element objects and React Fragment elements","isContextProvider returns false for non-element objects, primitives, null, and undefined","typeOf correctly identifies ContextProvider elements as matching the ContextProvider symbol"],"goal":"verify react-is.isContextProvider in pkg:npm/react-is@18.3.1","kind":"HOW","packages":["pkg:npm/react-is@18.3.1"],"schemaVersion":1,"symbols":["react-is.isContextProvider"]},"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.isContextProvider"],"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 isContextProvider in pkg:npm/react-is@18.3.1",
  "type": "module",
  "main": "src/index.js",
  "dependencies": {
    "react-is": "18.3.1"
  }
}

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

import {
  isContextProvider,
  ContextProvider,
  typeOf,
} from 'react-is';

/**
 * Check if the given value is a React Context Provider element.
 *
 * @param {*} value - The value to check.
 * @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 to inspect.
 * @returns {symbol|undefined} The matched React symbol or undefined.
 */
export function identifyTypeOf(value) {
  return typeOf(value);
}

export {
  isContextProvider,
  ContextProvider,
  typeOf,
};

import assert from 'node:assert/strict';
import {
  checkIsContextProvider,
  identifyTypeOf,
  isContextProvider,
  ContextProvider,
  typeOf,
} from '../src/index.js';

// 1. Export types
assert.equal(typeof isContextProvider, 'function', 'isContextProvider should be a function');
assert.equal(typeof checkIsContextProvider, 'function', 'checkIsContextProvider should be a function');
assert.equal(typeof typeOf, 'function', 'typeOf should be a function');
assert.equal(typeof identifyTypeOf, 'function', 'identifyTypeOf should be a function');
assert.equal(typeof ContextProvider, 'symbol', 'ContextProvider should be a symbol');

// 2. Context Provider element detection
const contextProviderElement = {
  $$typeof: Symbol.for('react.element'),
  type: {
    $$typeof: Symbol.for('react.provider'),
    _context: {},
  },
  props: { value: 'test-value' },
  key: null,
  ref: null,
};

assert.equal(isContextProvider(contextProviderElement), true, 'Context provider element must be identified by isContextProvider');
assert.equal(checkIsContextProvider(contextProviderElement), true, 'checkIsContextProvider helper must return true');

// 3. Rejection of Context Consumer element
const contextConsumerElement = {
  $$typeof: Symbol.for('react.element'),
  type: {
    $$typeof: Symbol.for('react.context'),
  },
  props: {},
  key: null,
  ref: null,
};
assert.equal(isContextProvider(contextConsumerElement), false, 'Context consumer element must not be identified as ContextProvider');

// 4. Rejection of plain DOM and Fragment elements
const plainElement = {
  $$typeof: Symbol.for('react.element'),
  type: 'div',
  props: { className: 'container' },
  key: null,
  ref: null,
};
const fragmentElement = {
  $$typeof: Symbol.for('react.element'),
  type: Symbol.for('react.fragment'),
  props: {},
  key: null,
  ref: null,
};
assert.equal(isContextProvider(plainElement), false, 'div element is not a ContextProvider');
assert.equal(isContextProvider(fragmentElement), false, 'Fragment element is not a ContextProvider');

// 5. Rejection of non-elements and primitives
assert.equal(isContextProvider({}), false, 'Empty object is not a ContextProvider');
assert.equal(isContextProvider(null), false, 'null is not a ContextProvider');
assert.equal(isContextProvider(undefined), false, 'undefined is not a ContextProvider');
assert.equal(isContextProvider('provider'), false, 'String is not a ContextProvider');
assert.equal(isContextProvider(123), false, 'Number is not a ContextProvider');

// 6. typeOf validation
assert.equal(typeOf(contextProviderElement), ContextProvider, 'typeOf(contextProviderElement) must equal ContextProvider symbol');
assert.equal(identifyTypeOf(contextProviderElement), ContextProvider, 'identifyTypeOf helper must return ContextProvider symbol');
assert.equal(typeOf(plainElement) !== ContextProvider, true, 'typeOf on plain element must not equal ContextProvider');
assert.equal(typeOf({}), undefined, 'typeOf on non-element must return undefined');

console.log('All contract tests for react-is.isContextProvider passed successfully.');