p-map 7.1.1: pMap, pMapIterable, pMapKeyed

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

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

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:7787d6ea2f13e44fb708a2c8299f8fe14bc81794d84134267790419814352099","contract":["pMap maps input elements concurrently up to options.concurrency while preserving input order","pMap omits elements returning pMapSkip and stops iteration early when a mapper returns pMapStop","pMap with stopOnError: false collects all rejections into an AggregateError ordered by input position","pMapSettled resolves to fulfilled and rejected PromiseSettledResult objects in input order while omitting pMapSkip","pMapKeyed and pMapSettledKeyed map object properties into a null-prototype object and Map entries into a new Map","pMapIterable streams mapped items as an AsyncIterable with concurrency and backpressure limits while honoring pMapSkip and pMapStop"],"goal":"verify pkg:npm/p-map@7.1.1","kind":"HOW","packages":["pkg:npm/p-map@7.1.1"],"schemaVersion":1,"symbols":["pMap","pMapIterable","pMapKeyed","pMapSettled","pMapSettledKeyed","pMapSkip","pMapStop"]},"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","pMapIterable","pMapKeyed","pMapSettled","pMapSettledKeyed","pMapSkip","pMapStop"],"verifierAdapter":"node-typescript@1"}

{
  "name": "verify-p-map",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "verify-p-map",
      "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",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "p-map": "7.1.1"
  }
}

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

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

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

// 1. pMap maps elements concurrently while preserving input order and respecting concurrency limit
{
  let active = 0;
  let maxActive = 0;
  const inputs = [30, 10, 20, 5];
  const results = await pMap(
    inputs,
    async (val, index) => {
      active++;
      if (active > maxActive) maxActive = active;
      await delay(val);
      active--;
      return `${index}:${val * 2}`;
    },
    { concurrency: 2 }
  );
  assert.deepEqual(results, ['0:60', '1:20', '2:40', '3:10']);
  assert.equal(maxActive, 2);
}

// 2. pMap supports pMapSkip and pMapStop control symbols
{
  const filtered = await pMap([1, 2, 3, 4, 5], async (n) => {
    if (n % 2 === 0) return pMapSkip;
    if (n === 5) return pMapStop;
    return n * 10;
  }, { concurrency: 1 });
  assert.deepEqual(filtered, [10, 30]);
}

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

// 4. pMapSettled returns fulfilled and rejected settled descriptors in input order and honors pMapSkip
{
  const settled = await pMapSettled(
    ['ok', 'skip', 'fail'],
    async (item) => {
      if (item === 'skip') return pMapSkip;
      if (item === 'fail') throw new Error('boom');
      return item.toUpperCase();
    },
    { concurrency: 2 }
  );
  assert.equal(settled.length, 2);
  assert.deepEqual(settled[0], { status: 'fulfilled', value: 'OK' });
  assert.equal(settled[1].status, 'rejected');
  assert.equal(settled[1].reason.message, 'boom');
}

// 5. pMapKeyed and pMapSettledKeyed map objects (with null prototype) and Maps while honoring pMapSkip
{
  const objOut = await pMapKeyed(
    { a: 2, b: 3, c: 4 },
    async (val, key) => (key === 'b' ? pMapSkip : `${key}=${val * 10}`),
    { concurrency: 2 }
  );
  assert.equal(Object.getPrototypeOf(objOut), null);
  assert.deepEqual({ ...objOut }, { a: 'a=20', c: 'c=40' });

  const mapInput = new Map([
    ['x', 10],
    ['y', 20],
  ]);
  const mapOut = await pMapSettledKeyed(
    mapInput,
    async (val, key) => {
      if (key === 'y') throw new Error('y-failed');
      return val + 1;
    },
    { concurrency: 2 }
  );
  assert.ok(mapOut instanceof Map);
  assert.deepEqual(mapOut.get('x'), { status: 'fulfilled', value: 11 });
  assert.equal(mapOut.get('y').status, 'rejected');
  assert.equal(mapOut.get('y').reason.message, 'y-failed');
}

// 6. pMapIterable streams mapped items with concurrency, backpressure, pMapSkip, and pMapStop
{
  const collected = [];
  for await (const item of pMapIterable(
    [1, 2, 3, 4, 5],
    async (n) => {
      if (n === 2) return pMapSkip;
      if (n === 4) return pMapStop;
      return n * 100;
    },
    { concurrency: 2, backpressure: 2, preserveOrder: true }
  )) {
    collected.push(item);
  }
  assert.deepEqual(collected, [100, 300]);
}