@vitest/utils 4.1.10: deepMerge

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

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:00d2e5351b53c521170ee281a5c15d6a703242d8c2aac8231505f2aabb3dd7b7","contract":["deepMerge recursively merges nested plain object properties into the target object","deepMerge mutates and returns the target object reference","deepMerge overwrites primitive properties and array values rather than merging them","deepMerge sequentially merges multiple source objects from left to right","deepMerge ignores undefined sources and returns target unchanged when non-plain objects are provided"],"goal":"verify @vitest/utils.deepMerge in pkg:npm/%40vitest/utils@4.1.10","kind":"HOW","packages":["pkg:npm/%40vitest/utils@4.1.10"],"schemaVersion":1,"symbols":["@vitest/utils.deepMerge"]},"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/%40vitest/utils@4.1.10"],"schemaVersion":1,"subject":"pkg:npm/%40vitest/utils@4.1.10","symbols":["@vitest/utils.deepMerge"],"verifierAdapter":"node-typescript@1"}

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

export { deepMerge };

export function mergeConfigs(base, ...overrides) {
  return deepMerge(base, ...overrides);
}

{
  "name": "sample-vitest-utils-deepmerge",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-vitest-utils-deepmerge",
      "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-deepmerge",
  "version": "1.0.0",
  "type": "module",
  "main": "index.mjs",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "@vitest/utils": "4.1.10"
  }
}

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

import assert from 'node:assert/strict';
import { deepMerge } from '@vitest/utils/helpers';
import { mergeConfigs } from '../index.mjs';

// 1. deepMerge recursively merges nested plain object properties into the target object
{
  const target = {
    app: {
      name: 'demo-service',
      settings: {
        timeout: 5000,
        retries: 3,
      },
    },
    version: 1,
  };
  const source = {
    app: {
      settings: {
        timeout: 10000,
        debug: true,
      },
      env: 'production',
    },
    features: ['cache'],
  };

  const result = deepMerge(target, source);
  assert.equal(result, target);
  assert.deepEqual(target, {
    app: {
      name: 'demo-service',
      settings: {
        timeout: 10000,
        retries: 3,
        debug: true,
      },
      env: 'production',
    },
    version: 1,
    features: ['cache'],
  });

  // deep 3-level nesting
  const t2 = { l1: { l2: { a: 'orig', b: 'keep' } } };
  const s2 = { l1: { l2: { a: 'updated', c: 'added' } } };
  deepMerge(t2, s2);
  assert.deepEqual(t2, { l1: { l2: { a: 'updated', b: 'keep', c: 'added' } } });
}

// 2. deepMerge mutates and returns the target object reference
{
  const original = { id: 100, profile: { role: 'user' } };
  const patch = { profile: { role: 'admin' }, active: true };
  const merged = deepMerge(original, patch);

  assert.equal(merged, original);
  assert.equal(original.profile.role, 'admin');
  assert.equal(original.active, true);

  // Source object must remain unchanged
  assert.deepEqual(patch, { profile: { role: 'admin' }, active: true });
}

// 3. deepMerge overwrites primitive properties and array values rather than merging them
{
  const target = {
    count: 10,
    label: 'initial',
    items: [1, 2, 3],
    nested: { flag: false, list: ['a', 'b'] },
  };
  const source = {
    count: 20,
    label: 'updated',
    items: [4, 5],
    nested: { flag: true, list: ['c'] },
  };

  deepMerge(target, source);
  assert.equal(target.count, 20);
  assert.equal(target.label, 'updated');
  assert.deepEqual(target.items, [4, 5]);
  assert.equal(target.nested.flag, true);
  assert.deepEqual(target.nested.list, ['c']);

  // Overwriting an object with a primitive replaces the object
  const objTarget = { data: { inner: 'val' } };
  deepMerge(objTarget, { data: 'reset' });
  assert.equal(objTarget.data, 'reset');
}

// 4. deepMerge sequentially merges multiple source objects from left to right
{
  const target = { a: 1, config: { x: 10 } };
  const s1 = { b: 2, config: { y: 20 } };
  const s2 = { c: 3, config: { x: 99, z: 30 } };
  const s3 = { d: 4 };

  const merged = deepMerge(target, s1, s2, s3);
  assert.equal(merged, target);
  assert.deepEqual(target, {
    a: 1,
    b: 2,
    c: 3,
    d: 4,
    config: {
      x: 99,
      y: 20,
      z: 30,
    },
  });

  // Verify through index.mjs helper function
  const base = { theme: 'light', font: { size: 12, family: 'sans' } };
  const res = mergeConfigs(base, { theme: 'dark' }, { font: { size: 14 } });
  assert.equal(res, base);
  assert.deepEqual(base, {
    theme: 'dark',
    font: { size: 14, family: 'sans' },
  });
}

// 5. deepMerge ignores undefined sources and returns target unchanged when non-plain objects are provided
{
  const target = { key: 'value', count: 1 };

  // Call with no sources
  assert.equal(deepMerge(target), target);
  assert.deepEqual(target, { key: 'value', count: 1 });

  // Call with undefined source
  assert.equal(deepMerge(target, undefined), target);
  assert.deepEqual(target, { key: 'value', count: 1 });

  // Non-plain object sources (null, primitive, array) are ignored and do not corrupt target
  deepMerge(target, null);
  assert.deepEqual(target, { key: 'value', count: 1 });

  deepMerge(target, 'string-arg');
  assert.deepEqual(target, { key: 'value', count: 1 });

  deepMerge(target, [1, 2, 3]);
  assert.deepEqual(target, { key: 'value', count: 1 });

  // Calling deepMerge on a non-plain target returns target as-is
  assert.equal(deepMerge(42, { a: 1 }), 42);
  assert.equal(deepMerge('hello', { a: 1 }), 'hello');
  assert.equal(deepMerge(null, { a: 1 }), null);
}

console.log('All @vitest/utils deepMerge contract assertions passed.');