react-is 19.2.8: isMemo

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

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:c72a334296d98eea22b4b610dcb0b33ac37585a39251e092694c564a9a081077","contract":["isMemo returns true for React elements whose component type is wrapped with react.memo","isMemo returns false for bare react.memo component type objects without an element wrapper","isMemo returns false for standard DOM elements, non-memo elements, non-element objects, and primitives"],"goal":"verify react-is.isMemo in pkg:npm/react-is@19.2.8","kind":"HOW","packages":["pkg:npm/react-is@19.2.8"],"schemaVersion":1,"symbols":["react-is.isMemo"]},"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.isMemo"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-react-is-memo",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-react-is-memo",
      "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-memo",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification of react-is.isMemo for React 19",
  "type": "module",
  "main": "src/index.mjs",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "react-is": "19.2.8"
  },
  "license": "MIT-0"
}

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

import { isMemo, Memo, Element } from 'react-is';

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

/**
 * Create a mock React element with the specified type, props, and transitional element marker.
 *
 * @param {*} type - The element type.
 * @param {object} [props={}] - Optional props object.
 * @returns {object} Mock React element object.
 */
export function createMockElement(type, props = {}) {
  return {
    $$typeof: Element,
    type,
    props,
    key: null,
    ref: null,
  };
}

/**
 * Create a mock React memo component type wrapper.
 *
 * @param {function} renderFn - Underlying render function component.
 * @param {function|null} [compare=null] - Optional comparator function.
 * @returns {object} Mock React memo component type object.
 */
export function createMockMemoType(renderFn, compare = null) {
  return {
    $$typeof: Memo,
    type: renderFn,
    compare,
  };
}

export { isMemo, Memo, Element };

import assert from 'node:assert/strict';
import {
  checkIsMemo,
  createMockElement,
  createMockMemoType,
  isMemo,
  Memo,
  Element,
} from '../src/index.mjs';

// 1. isMemo returns true for React elements whose component type is wrapped with react.memo
{
  const memoType = createMockMemoType(function Card(props) {
    return null;
  });
  const memoElement = createMockElement(memoType, { title: 'Test Card' });

  assert.equal(
    isMemo(memoElement),
    true,
    'isMemo must return true for React element created with memo component'
  );
  assert.equal(
    checkIsMemo(memoElement),
    true,
    'checkIsMemo helper must return true for memo element'
  );

  // Memo element with custom comparator
  const customMemoType = createMockMemoType(
    function Item(props) {
      return null;
    },
    (prev, next) => prev.id === next.id
  );
  const customMemoElement = createMockElement(customMemoType, { id: 1 });
  assert.equal(
    isMemo(customMemoElement),
    true,
    'isMemo must return true for memo element with custom comparator'
  );
}

// 2. isMemo returns false for bare react.memo component type objects without an element wrapper
{
  const memoType = createMockMemoType(function Header(props) {
    return null;
  });

  assert.equal(
    isMemo(memoType),
    false,
    'isMemo must return false when passed the memo component type directly'
  );
  assert.equal(
    checkIsMemo(memoType),
    false,
    'checkIsMemo helper must return false for bare memo component type'
  );
}

// 3. isMemo returns false for standard DOM elements, non-memo elements, non-element objects, and primitives
{
  // Standard DOM element
  const domElement = createMockElement('div', { className: 'container' });
  assert.equal(isMemo(domElement), false, 'isMemo must return false for standard DOM element');

  // Plain function component element
  const fnElement = createMockElement(function PlainComponent() {
    return null;
  });
  assert.equal(isMemo(fnElement), false, 'isMemo must return false for plain function component element');

  // React elements with other special types
  const forwardRefElement = createMockElement({
    $$typeof: Symbol.for('react.forward_ref'),
    render: () => null,
  });
  assert.equal(isMemo(forwardRefElement), false, 'isMemo must return false for forward_ref element');

  const fragmentElement = {
    $$typeof: Element,
    type: Symbol.for('react.fragment'),
    props: {},
    key: null,
    ref: null,
  };
  assert.equal(isMemo(fragmentElement), false, 'isMemo must return false for fragment element');

  // Non-element objects and primitives
  assert.equal(isMemo({}), false, 'isMemo must return false for plain empty object');
  assert.equal(isMemo({ $$typeof: Element }), false, 'isMemo must return false for element without type');
  assert.equal(isMemo(null), false, 'isMemo must return false for null');
  assert.equal(isMemo(undefined), false, 'isMemo must return false for undefined');
  assert.equal(isMemo('div'), false, 'isMemo must return false for string');
  assert.equal(isMemo(100), false, 'isMemo must return false for number');
  assert.equal(isMemo(true), false, 'isMemo must return false for boolean');
  assert.equal(isMemo(Memo), false, 'isMemo must return false for Memo symbol');
  assert.equal(isMemo(Element), false, 'isMemo must return false for Element symbol');
}

console.log('Contract tests for react-is.isMemo (pkg:npm/react-is@19.2.8) passed successfully.');