@vitest/utils 4.1.10: unique

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 @vitest/utils.unique in pkg:npm/%40vitest/utils@4.1.10
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/%40vitest/utils@4.1.10
Demonstrate these symbols/APIs:
  - @vitest/utils.unique

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:0e54dd98e36eac5cd620bbcbee026813988d823e24a1c40d671b6ac837472d8d","contract":["unique removes duplicate primitive values while preserving first occurrence order","unique removes duplicate object references while preserving distinct object references","unique handles undefined, null, boolean, and NaN values with SameValueZero semantics","unique handles symbols and BigInt values correctly","unique returns an empty array for empty inputs and returns a new array instance","deduplicateArray and unionArrays helpers wrap unique for array deduplication and set union"],"goal":"verify @vitest/utils.unique in pkg:npm/%40vitest/utils@4.1.10","kind":"HOW","packages":["pkg:npm/%40vitest/utils@4.1.10"],"schemaVersion":1,"symbols":["@vitest/utils.unique"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/%40vitest/utils@4.1.10"],"schemaVersion":1,"subject":"pkg:npm/%40vitest/utils@4.1.10","symbols":["@vitest/utils.unique"],"verifierAdapter":"node-typescript@1"}

import { unique } from '@vitest/utils/helpers';

export { unique };

/**
 * Deduplicates an array of items, preserving first occurrence order.
 *
 * @template T
 * @param {T[]} items - Array of items to deduplicate.
 * @returns {T[]} Array with duplicates removed.
 */
export function deduplicateArray(items) {
  return unique(items);
}

/**
 * Combines multiple arrays and deduplicates elements into a single array.
 *
 * @template T
 * @param {...T[]} arrays - Multiple arrays to union and deduplicate.
 * @returns {T[]} Union of elements without duplicates.
 */
export function unionArrays(...arrays) {
  return unique(arrays.flat());
}

{
  "name": "sample-vitest-utils-unique",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-vitest-utils-unique",
      "version": "1.0.0",
      "dependencies": {
        "@vitest/utils": "4.1.10"
      }
    },
    "node_modules/@vitest/pretty-format": {
      "version": "4.1.10",
      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.10.tgz",
      "integrity": "sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==",
      "license": "MIT",
      "dependencies": {
        "tinyrainbow": "^3.1.0"
      },
      "funding": {
        "url": "https://opencollective.com/vitest"
      }
    },
    "node_modules/@vitest/utils": {
      "version": "4.1.10",
      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.10.tgz",
      "integrity": "sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==",
      "license": "MIT",
      "dependencies": {
        "@vitest/pretty-format": "4.1.10",
        "convert-source-map": "^2.0.0",
        "tinyrainbow": "^3.1.0"
      },
      "funding": {
        "url": "https://opencollective.com/vitest"
      }
    },
    "node_modules/convert-source-map": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
      "license": "MIT"
    },
    "node_modules/tinyrainbow": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.1.tgz",
      "integrity": "sha512-yau8yJdTt989Mm0Bd/236QnzEiPf2xLLTqUZRUJOo/3CB078LSwzei343DgtJVmfJKJE3TMINY1u42SQsP6mXw==",
      "license": "MIT",
      "engines": {
        "node": ">=14.0.0"
      }
    }
  }
}

{
  "name": "sample-vitest-utils-unique",
  "version": "1.0.0",
  "description": "Clean-room verification sample for @vitest/utils unique",
  "type": "module",
  "main": "index.mjs",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "@vitest/utils": "4.1.10"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify @vitest/utils.unique in pkg:npm/%40vitest/utils@4.1.10",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40vitest/utils@4.1.10"
  ],
  "symbols": [
    "@vitest/utils.unique"
  ]
}

import assert from 'node:assert/strict';
import { unique } from '@vitest/utils/helpers';
import { deduplicateArray, unionArrays } from '../index.mjs';

// 1. unique removes duplicate primitive values while preserving first occurrence order
{
  const numbers = [3, 1, 2, 3, 2, 1, 4, 5, 4];
  const uniqueNumbers = unique(numbers);
  assert.deepEqual(uniqueNumbers, [3, 1, 2, 4, 5]);

  const strings = ['banana', 'apple', 'banana', 'cherry', 'apple', 'date'];
  const uniqueStrings = unique(strings);
  assert.deepEqual(uniqueStrings, ['banana', 'apple', 'cherry', 'date']);
}

// 2. unique removes duplicate object references while preserving distinct object references
{
  const ref1 = { id: 1 };
  const ref2 = { id: 1 };
  const ref3 = { id: 2 };

  const mixed = [ref1, ref2, ref1, ref3, ref2];
  const result = unique(mixed);

  assert.equal(result.length, 3);
  assert.equal(result[0], ref1);
  assert.equal(result[1], ref2);
  assert.equal(result[2], ref3);
}

// 3. unique handles undefined, null, boolean, and NaN values with SameValueZero semantics
{
  const primitives = [null, undefined, null, true, false, true, undefined];
  assert.deepEqual(unique(primitives), [null, undefined, true, false]);

  const nans = [NaN, 1, NaN, 2, NaN];
  const nanResult = unique(nans);
  assert.equal(nanResult.length, 3);
  assert.ok(Number.isNaN(nanResult[0]));
  assert.equal(nanResult[1], 1);
  assert.equal(nanResult[2], 2);
}

// 4. unique handles symbols and BigInt values correctly
{
  const symA = Symbol('test');
  const symB = Symbol('test');
  const symbols = [symA, symB, symA, symB];
  const symbolResult = unique(symbols);
  assert.deepEqual(symbolResult, [symA, symB]);

  const bigints = [10n, 20n, 10n, 30n, 20n];
  assert.deepEqual(unique(bigints), [10n, 20n, 30n]);
}

// 5. unique returns an empty array for empty inputs and returns a new array instance
{
  const empty = [];
  const emptyResult = unique(empty);
  assert.deepEqual(emptyResult, []);
  assert.notEqual(emptyResult, empty, 'unique must return a new array instance');

  const single = [42];
  const singleResult = unique(single);
  assert.deepEqual(singleResult, [42]);
  assert.notEqual(singleResult, single, 'unique must return a new array instance');
}

// 6. deduplicateArray and unionArrays helpers wrap unique for array deduplication and set union
{
  const deduped = deduplicateArray(['x', 'y', 'x', 'z']);
  assert.deepEqual(deduped, ['x', 'y', 'z']);

  const union = unionArrays([1, 2, 3], [2, 3, 4], [4, 5, 6]);
  assert.deepEqual(union, [1, 2, 3, 4, 5, 6]);
}

console.log('All contract assertions passed.');