@vitest/utils 4.1.10: deepClone

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.deepClone 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.deepClone
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:c8bb2fb54fca96c9d4881e1195ea1f97537da5bad719718c41661b2594c61a0c","constraints":{"executionContext":"node"},"contract":["deepClone is exported as a function from @vitest/utils/helpers","deepClone creates an independent deep copy of nested objects and arrays","deepClone handles circular references without infinite recursion","deepClone preserves prototype chain and custom descriptors","deepClone forceWritable option converts read-only properties to writable properties","deepClone returns primitive values and immutable types unchanged"],"goal":"verify @vitest/utils.deepClone in pkg:npm/%40vitest/utils@4.1.10","kind":"HOW","packages":["pkg:npm/%40vitest/utils@4.1.10"],"schemaVersion":1,"symbols":["@vitest/utils.deepClone"]},"contractCommand":["node","test/contract.mjs"],"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/%40vitest/utils@4.1.10"],"schemaVersion":1,"subject":"pkg:npm/%40vitest/utils@4.1.10","symbols":["@vitest/utils.deepClone"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-vitest-utils-deep-clone",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-vitest-utils-deep-clone",
      "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-deep-clone",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification of deepClone in @vitest/utils@4.1.10",
  "type": "module",
  "main": "src/index.js",
  "dependencies": {
    "@vitest/utils": "4.1.10"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify @vitest/utils.deepClone in pkg:npm/%40vitest/utils@4.1.10",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40vitest/utils@4.1.10"
  ],
  "symbols": [
    "@vitest/utils.deepClone"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

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

/**
 * Perform a deep clone of a given value using @vitest/utils/helpers deepClone.
 *
 * @template T
 * @param {T} value - Value to deep clone.
 * @param {{ forceWritable?: boolean }} [options] - Clone options.
 * @returns {T} Cloned value.
 */
export function cloneValue(value, options) {
  return deepClone(value, options);
}

/**
 * Deep clone an object with forceWritable enabled.
 *
 * @template T
 * @param {T} value - Object to clone.
 * @returns {T} Cloned object with writable properties.
 */
export function cloneWritable(value) {
  return deepClone(value, { forceWritable: true });
}

export { deepClone };

import assert from 'node:assert/strict';
import { deepClone as directDeepClone } from '@vitest/utils/helpers';
import { deepClone, cloneValue, cloneWritable } from '../src/index.js';

// 1. deepClone is exported as a function from @vitest/utils/helpers
assert.equal(typeof directDeepClone, 'function', 'directDeepClone must be a function');
assert.equal(typeof deepClone, 'function', 'deepClone export must be a function');
assert.equal(deepClone, directDeepClone, 'exported deepClone must match library deepClone');
assert.equal(typeof cloneValue, 'function', 'cloneValue helper must be a function');
assert.equal(typeof cloneWritable, 'function', 'cloneWritable helper must be a function');

// 2. deepClone creates an independent deep copy of nested objects and arrays
{
  const original = {
    num: 42,
    str: 'sample-string',
    nested: { flag: true, inner: { value: 'deep' } },
    arr: [1, 2, { item: 'first' }],
  };

  const cloned = cloneValue(original);

  assert.deepEqual(cloned, original, 'cloned structure must deeply equal original');
  assert.notEqual(cloned, original, 'cloned reference must be distinct from original');
  assert.notEqual(cloned.nested, original.nested, 'nested object reference must be distinct');
  assert.notEqual(cloned.nested.inner, original.nested.inner, 'deep inner object reference must be distinct');
  assert.notEqual(cloned.arr, original.arr, 'array reference must be distinct');
  assert.notEqual(cloned.arr[2], original.arr[2], 'array item object reference must be distinct');

  cloned.nested.inner.value = 'mutated';
  assert.equal(original.nested.inner.value, 'deep', 'modifying clone must not mutate original object');

  cloned.arr[2].item = 'mutated-item';
  assert.equal(original.arr[2].item, 'first', 'modifying cloned array item must not mutate original array');
}

// 3. deepClone handles circular references without infinite recursion
{
  const circularObj = { name: 'circular-root' };
  circularObj.self = circularObj;
  circularObj.child = { parent: circularObj };

  const clonedCircular = deepClone(circularObj);

  assert.equal(clonedCircular.name, 'circular-root', 'cloned root property must match');
  assert.equal(clonedCircular.self, clonedCircular, 'circular self reference must point to cloned root');
  assert.notEqual(clonedCircular.self, circularObj, 'circular reference must not point to original');
  assert.equal(clonedCircular.child.parent, clonedCircular, 'circular nested reference must point to cloned root');
  assert.notEqual(clonedCircular.child.parent, circularObj, 'circular nested reference must not point to original');
}

// 4. deepClone preserves prototype chain and custom descriptors
{
  const prototypeBase = {
    inheritedMethod() {
      return 'inherited';
    },
  };

  const customObj = Object.create(prototypeBase);
  customObj.ownProp = 'own-value';

  const clonedCustom = deepClone(customObj);

  assert.equal(clonedCustom.ownProp, 'own-value', 'own properties must be preserved');
  assert.equal(clonedCustom.inheritedMethod(), 'inherited', 'inherited methods must be accessible');
  assert.equal(Object.getPrototypeOf(clonedCustom), prototypeBase, 'prototype reference must be preserved');

  const objWithGetter = {
    _val: 'getter-val',
    get val() {
      return this._val;
    },
  };
  const clonedGetter = deepClone(objWithGetter);
  assert.equal(clonedGetter.val, 'getter-val', 'getter property value must be preserved');
}

// 5. deepClone forceWritable option converts read-only properties to writable properties
{
  const readOnlyObj = {};
  Object.defineProperty(readOnlyObj, 'immutableKey', {
    value: 'original-readonly',
    writable: false,
    enumerable: true,
    configurable: true,
  });

  const standardClone = deepClone(readOnlyObj);
  const standardDesc = Object.getOwnPropertyDescriptor(standardClone, 'immutableKey');
  assert.equal(standardDesc.writable, false, 'default clone must preserve non-writable descriptor');

  const writableClone = cloneWritable(readOnlyObj);
  const writableDesc = Object.getOwnPropertyDescriptor(writableClone, 'immutableKey');
  assert.equal(writableDesc.writable, true, 'cloneWritable must make property descriptor writable');
  assert.equal(writableDesc.configurable, true, 'cloneWritable must keep descriptor configurable');

  writableClone.immutableKey = 'modified-readonly';
  assert.equal(writableClone.immutableKey, 'modified-readonly', 'forceWritable property must allow mutation');
  assert.equal(readOnlyObj.immutableKey, 'original-readonly', 'mutation must not alter original object');
}

// 6. deepClone returns primitive values and immutable types unchanged
{
  assert.equal(deepClone(null), null, 'null primitive must return null');
  assert.equal(deepClone(undefined), undefined, 'undefined primitive must return undefined');
  assert.equal(deepClone(12345), 12345, 'number primitive must return same number');
  assert.equal(deepClone('test-string'), 'test-string', 'string primitive must return same string');
  assert.equal(deepClone(true), true, 'boolean primitive must return same boolean');

  const sym = Symbol('contract-symbol');
  assert.equal(deepClone(sym), sym, 'symbol must return same symbol');

  const big = 12345678901234567890n;
  assert.equal(deepClone(big), big, 'bigint must return same bigint');
}

console.log('All @vitest/utils.deepClone contract checks passed successfully.');