@jest/expect-utils 30.4.1

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 pkg:npm/%40jest/expect-utils@30.4.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/%40jest/expect-utils@30.4.1
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

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:8eb432fb750aa71192e269981c836804a73f040f77e3a6c62ede345e959896d5","constraints":{"executionContext":"node"},"contract":["equals performs deep structural equality check on primitives, nested objects, and arrays","equals handles circular references without infinite recursion","equals supports custom tester functions for specialized value comparisons","equals with strictCheck true distinguishes between undefined properties and omitted properties","isA verifies object type tags matching standard constructor names","isError returns true for Error instances and false for non-error values","emptyObject returns true for empty objects or empty arrays and false for non-empty structures","getObjectKeys extracts own enumerable string keys from objects","getObjectSubset extracts matching properties and subsets from complex nested structures","getPath traverses nested object hierarchies with dot notation and returns traversed value and metadata","pathAsArray decomposes dot and bracket property paths into path segment arrays","partition splits an array into two arrays based on a predicate function","iterableEquality evaluates equality for Sets and Maps independent of insertion order where applicable","arrayBufferEquality compares ArrayBuffer contents byte by byte"],"goal":"verify pkg:npm/%40jest/expect-utils@30.4.1","kind":"HOW","packages":["pkg:npm/%40jest/expect-utils@30.4.1"],"schemaVersion":1},"contractCommand":["node","test/contract.js"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/%40jest/expect-utils@30.4.1"],"schemaVersion":1,"subject":"pkg:npm/%40jest/expect-utils@30.4.1","verifierAdapter":"node-typescript@1"}

'use strict';

const {
  equals,
  isA,
  isError,
  emptyObject,
  getObjectKeys,
  getObjectSubset,
  getPath,
  pathAsArray,
  partition,
  subsetEquality,
  iterableEquality,
  arrayBufferEquality,
  sparseArrayEquality,
  typeEquality,
} = require('@jest/expect-utils');

module.exports = {
  equals,
  isA,
  isError,
  emptyObject,
  getObjectKeys,
  getObjectSubset,
  getPath,
  pathAsArray,
  partition,
  subsetEquality,
  iterableEquality,
  arrayBufferEquality,
  sparseArrayEquality,
  typeEquality,
};

{
  "name": "sample-jest-expect-utils",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-jest-expect-utils",
      "version": "1.0.0",
      "dependencies": {
        "@jest/expect-utils": "30.4.1"
      }
    },
    "node_modules/@jest/expect-utils": {
      "version": "30.4.1",
      "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.4.1.tgz",
      "integrity": "sha512-ZBn5CglH8fBsQsvs4VWNzD4aWfUYks+IdOOQU3MEK71ol/BcVm+P+rtb1KpiFBpSWSCE27uOahyyf1vfqOVbcQ==",
      "license": "MIT",
      "dependencies": {
        "@jest/get-type": "30.1.0"
      },
      "engines": {
        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
      }
    },
    "node_modules/@jest/get-type": {
      "version": "30.1.0",
      "resolved": "https://registry.npmjs.org/@jest/get-type/-/get-type-30.1.0.tgz",
      "integrity": "sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA==",
      "license": "MIT",
      "engines": {
        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
      }
    }
  }
}

{
  "name": "sample-jest-expect-utils",
  "version": "1.0.0",
  "description": "Clean-room verification sample for @jest/expect-utils",
  "main": "index.js",
  "scripts": {
    "test": "node test/contract.js"
  },
  "dependencies": {
    "@jest/expect-utils": "30.4.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/%40jest/expect-utils@30.4.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40jest/expect-utils@30.4.1"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

'use strict';

const assert = require('node:assert/strict');
const {
  equals,
  isA,
  isError,
  emptyObject,
  getObjectKeys,
  getObjectSubset,
  getPath,
  pathAsArray,
  partition,
  subsetEquality,
  iterableEquality,
  arrayBufferEquality,
  sparseArrayEquality,
  typeEquality,
} = require('../index.js');

// 1. equals performs deep structural equality check on primitives, nested objects, and arrays
{
  assert.equal(equals(42, 42), true);
  assert.equal(equals('hello', 'hello'), true);
  assert.equal(equals(null, null), true);
  assert.equal(equals(undefined, undefined), true);
  assert.equal(equals({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }), true);
  assert.equal(equals({ a: 1, b: [2, 3] }, { a: 1, b: [2, 4] }), false);
}

// 2. equals handles circular references without infinite recursion
{
  const objA = { name: 'cyclic' };
  objA.self = objA;

  const objB = { name: 'cyclic' };
  objB.self = objB;

  assert.equal(equals(objA, objB), true);

  const objC = { name: 'cyclic-diff' };
  objC.self = objC;
  assert.equal(equals(objA, objC), false);
}

// 3. equals supports custom tester functions for specialized value comparisons
{
  const customTester = function (a, b) {
    if (typeof a === 'string' && typeof b === 'string') {
      return a.toLowerCase() === b.toLowerCase();
    }
    return undefined;
  };

  assert.equal(equals('Hello', 'hello', [customTester]), true);
  assert.equal(equals({ msg: 'TEST' }, { msg: 'test' }, [customTester]), true);
  assert.equal(equals({ msg: 'TEST' }, { msg: 'other' }, [customTester]), false);
}

// 4. equals with strictCheck true distinguishes between undefined properties and omitted properties
{
  const objMissing = { a: 1 };
  const objExplicitUndefined = { a: 1, b: undefined };

  // strictCheck false allows matching missing and undefined
  assert.equal(equals(objMissing, objExplicitUndefined, [], false), true);
  // strictCheck true rejects
  assert.equal(equals(objMissing, objExplicitUndefined, [], true), false);
}

// 5. isA verifies object type tags matching standard constructor names
{
  assert.equal(isA('Array', [1, 2, 3]), true);
  assert.equal(isA('Array', {}), false);
  assert.equal(isA('Date', new Date()), true);
  assert.equal(isA('Date', '2026-01-01'), false);
  assert.equal(isA('RegExp', /abc/), true);
  assert.equal(isA('Map', new Map()), true);
  assert.equal(isA('Set', new Set()), true);
}

// 6. isError returns true for Error instances and false for non-error values
{
  assert.equal(isError(new Error('standard error')), true);
  assert.equal(isError(new TypeError('type error')), true);
  class CustomError extends Error {}
  assert.equal(isError(new CustomError('custom error')), true);
  assert.equal(isError({ message: 'fake error' }), false);
  assert.equal(isError(null), false);
  assert.equal(isError('error string'), false);
}

// 7. emptyObject returns true for empty objects or empty arrays and false for non-empty structures
{
  assert.equal(emptyObject({}), true);
  assert.equal(emptyObject(Object.create(null)), true);
  assert.equal(emptyObject([]), true);
  assert.equal(emptyObject({ a: 1 }), false);
  assert.equal(emptyObject([1]), false);
  assert.equal(emptyObject(null), false);
  assert.equal(emptyObject(undefined), false);
}

// 8. getObjectKeys extracts own enumerable string keys from objects
{
  assert.deepEqual(getObjectKeys({ a: 1, b: 2 }), ['a', 'b']);
  assert.deepEqual(getObjectKeys({}), []);
}

// 9. getObjectSubset extracts matching properties and subsets from complex nested structures
{
  const source = {
    id: 101,
    profile: {
      name: 'Alice',
      age: 30,
      tags: ['admin', 'user'],
    },
    extra: 'ignored',
  };

  const subset = {
    profile: {
      name: 'Alice',
    },
  };

  const extracted = getObjectSubset(source, subset);
  assert.deepEqual(extracted, {
    profile: {
      name: 'Alice',
    },
  });
}

// 10. getPath traverses nested object hierarchies with dot notation and returns traversed value and metadata
{
  const nested = {
    user: {
      address: {
        city: 'Metropolis',
        zip: 12345,
      },
    },
  };

  const result = getPath(nested, 'user.address.city');
  assert.equal(result.value, 'Metropolis');
  assert.equal(result.hasEndProp, true);
  assert.equal(result.endPropIsDefined, true);
  assert.deepEqual(result.traversedPath, ['user', 'address', 'city']);

  const nonExistent = getPath(nested, 'user.address.country');
  assert.equal(nonExistent.value, undefined);
  assert.equal(nonExistent.hasEndProp, false);
}

// 11. pathAsArray decomposes dot and bracket property paths into path segment arrays
{
  assert.deepEqual(pathAsArray('user.profile.name'), ['user', 'profile', 'name']);
  assert.deepEqual(pathAsArray('items[0].id'), ['items', '0', 'id']);
  assert.deepEqual(pathAsArray('a.b[2][3].c'), ['a', 'b', '2', '3', 'c']);
}

// 12. partition splits an array into two arrays based on a predicate function
{
  const numbers = [1, 2, 3, 4, 5, 6];
  const [evens, odds] = partition(numbers, (n) => n % 2 === 0);
  assert.deepEqual(evens, [2, 4, 6]);
  assert.deepEqual(odds, [1, 3, 5]);
}

// 13. iterableEquality evaluates equality for Sets and Maps independent of insertion order where applicable
{
  const setA = new Set([1, 2, 3]);
  const setB = new Set([3, 2, 1]);
  assert.equal(iterableEquality(setA, setB), true);

  const mapA = new Map([
    ['k1', 'v1'],
    ['k2', 'v2'],
  ]);
  const mapB = new Map([
    ['k2', 'v2'],
    ['k1', 'v1'],
  ]);
  assert.equal(iterableEquality(mapA, mapB), true);

  const mapC = new Map([['k1', 'v-different']]);
  assert.equal(iterableEquality(mapA, mapC), false);
}

// 14. arrayBufferEquality compares ArrayBuffer contents byte by byte
{
  const buf1 = new Uint8Array([10, 20, 30]).buffer;
  const buf2 = new Uint8Array([10, 20, 30]).buffer;
  const buf3 = new Uint8Array([10, 20, 40]).buffer;

  assert.equal(arrayBufferEquality(buf1, buf2), true);
  assert.equal(arrayBufferEquality(buf1, buf3), false);
}

console.log('All @jest/expect-utils contract assertions passed.');