p-map 7.1.1: pMap

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 pMap in pkg:npm/p-map@7.1.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/p-map@7.1.1
Demonstrate these symbols/APIs:
  - pMap

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:71ec1f3ad68592fab599715fd595527b52d95e4b126abbd1c0a0a6629b7cbc8f","contract":["pMap maps iterable elements concurrently up to options.concurrency while preserving input order","pMap accepts an AsyncIterable input, omits pMapSkip items, and halts iteration early on pMapStop","pMap with stopOnError: false collects all rejections into an AggregateError ordered by input position","pMap aborts when options.signal is aborted and rejects with the AbortSignal reason"],"goal":"verify pMap in pkg:npm/p-map@7.1.1","kind":"HOW","packages":["pkg:npm/p-map@7.1.1"],"schemaVersion":1,"symbols":["pMap"]},"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/p-map@7.1.1"],"schemaVersion":1,"subject":"pkg:npm/p-map@7.1.1","symbols":["pMap"],"verifierAdapter":"node-typescript@1"}

{
  "name": "verify-p-map-pmap",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "verify-p-map-pmap",
      "version": "1.0.0",
      "dependencies": {
        "p-map": "7.1.1"
      }
    },
    "node_modules/p-map": {
      "version": "7.1.1",
      "resolved": "https://registry.npmjs.org/p-map/-/p-map-7.1.1.tgz",
      "integrity": "sha512-6Lh3jQPLthYujSrlw6ccWXBGZTkoTCz27Hd92g79LH/kjAbgoEu0t442cCCNbegPSJsA0lwDX8z0bcKtkpA32g==",
      "license": "MIT",
      "engines": {
        "node": ">=18"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    }
  }
}

{
  "name": "verify-p-map-pmap",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "p-map": "7.1.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pMap in pkg:npm/p-map@7.1.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/p-map@7.1.1"
  ],
  "symbols": [
    "pMap"
  ]
}

import assert from 'node:assert/strict';
import pMap, { pMapSkip, pMapStop } from 'p-map';

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// 1. pMap maps iterable elements concurrently up to options.concurrency while preserving input order
{
  let active = 0;
  let maxActive = 0;
  const inputs = [30, 10, 20, 5];
  const mapped = await pMap(
    inputs,
    async (value, index) => {
      active++;
      if (active > maxActive) {
        maxActive = active;
      }
      await delay(value);
      active--;
      return `${index}:${value * 2}`;
    },
    { concurrency: 2 }
  );

  assert.deepEqual(mapped, ['0:60', '1:20', '2:40', '3:10']);
  assert.equal(maxActive, 2);
}

// 2. pMap accepts an AsyncIterable input, omits pMapSkip items, and halts iteration early on pMapStop
{
  async function* generateNumbers() {
    for (const n of [1, 2, 3, 4, 5]) {
      yield n;
    }
  }

  const visited = [];
  const filtered = await pMap(
    generateNumbers(),
    async (n) => {
      visited.push(n);
      if (n === 2) return pMapSkip;
      if (n === 4) return pMapStop;
      return n * 10;
    },
    { concurrency: 1 }
  );

  assert.deepEqual(filtered, [10, 30]);
  assert.deepEqual(visited, [1, 2, 3, 4]);
}

// 3. pMap with stopOnError: false collects all rejections into an AggregateError in input order
{
  await assert.rejects(
    async () => {
      await pMap(
        [25, 5, 15],
        async (ms, index) => {
          await delay(ms);
          if (index === 0) throw new Error('first-failure');
          if (index === 2) throw new Error('third-failure');
          return index;
        },
        { concurrency: 3, stopOnError: false }
      );
    },
    (error) => {
      assert.ok(error instanceof AggregateError);
      assert.deepEqual(
        error.errors.map((e) => e.message),
        ['first-failure', 'third-failure']
      );
      return true;
    }
  );
}

// 4. pMap aborts immediately when signal is aborted and rejects with the signal reason
{
  const controller = new AbortController();
  const customReason = new Error('aborted-by-signal');

  await assert.rejects(
    async () => {
      await pMap(
        [1, 2, 3],
        async (item) => {
          if (item === 2) {
            controller.abort(customReason);
          }
          await delay(20);
          return item;
        },
        { concurrency: 2, signal: controller.signal }
      );
    },
    (error) => {
      assert.equal(error, customReason);
      return true;
    }
  );
}