p-map 7.1.1: 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 p-map.pMapKeyed 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:
  - p-map.pMapKeyed

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:d31ea131a34be9730ebd547fe98edf0913f8c93bad4be36738341124bee392e8","contract":["pMapKeyed(objectInput, mapper, options) awaits each enumerable own property value (including symbol keys) and resolves to a null-prototype object preserving key order with mapped values","pMapKeyed(mapInput, mapper, options) iterates Map entries and resolves to a new Map instance with mapped values","Returning pMapSkip from mapper omits that key from the returned object or Map, while returning pMapStop stops further keys and keeps only preceding keys","With stopOnError: false, rejections from mappers are collected in key order and rejected as an AggregateError"],"goal":"verify p-map.pMapKeyed in pkg:npm/p-map@7.1.1","kind":"HOW","packages":["pkg:npm/p-map@7.1.1"],"schemaVersion":1,"symbols":["p-map.pMapKeyed"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/p-map@7.1.1"],"schemaVersion":1,"subject":"pkg:npm/p-map@7.1.1","symbols":["p-map.pMapKeyed"],"verifierAdapter":"node-typescript@1"}

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

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

import { pMapKeyed, pMapSkip, pMapStop } from "p-map";

export async function mapObjectValues(input, mapper, options) {
  return pMapKeyed(input, mapper, options);
}

export { pMapKeyed, pMapSkip, pMapStop };

import assert from "node:assert/strict";
import { pMapKeyed, pMapSkip, pMapStop } from "../src/index.mjs";

// 1. Plain object with sync and Promise values, returns null-prototype object preserving key order
const symKey = Symbol("tag");
const objInput = {
  alpha: Promise.resolve(10),
  beta: 20,
  [symKey]: Promise.resolve(5),
};
const objResult = await pMapKeyed(
  objInput,
  async (value, key) => {
    const label = typeof key === "symbol" ? key.description : key;
    return `${label}:${value * 2}`;
  },
  { concurrency: 2 }
);

assert.equal(Object.getPrototypeOf(objResult), null);
assert.deepEqual(Reflect.ownKeys(objResult), ["alpha", "beta", symKey]);
assert.equal(objResult.alpha, "alpha:20");
assert.equal(objResult.beta, "beta:40");
assert.equal(objResult[symKey], "tag:10");

// 2. Map input returns a new Map with mapped values
const mapInput = new Map([
  ["first", Promise.resolve(3)],
  ["second", 7],
]);
const mapResult = await pMapKeyed(mapInput, async (value, key) => `${key}=${value + 1}`);
assert.ok(mapResult instanceof Map);
assert.notEqual(mapResult, mapInput);
assert.deepEqual([...mapResult.entries()], [
  ["first", "first=4"],
  ["second", "second=8"],
]);

// 3. pMapSkip omits skipped keys and pMapStop keeps only preceding keys
const skippedResult = await pMapKeyed(
  { a: 1, b: 2, c: 3, d: 4 },
  async (value, key) => {
    if (key === "b") return pMapSkip;
    if (key === "d") return pMapStop;
    return value * 10;
  },
  { concurrency: 1 }
);
assert.deepEqual(Object.keys(skippedResult), ["a", "c"]);
assert.equal(skippedResult.a, 10);
assert.equal(skippedResult.c, 30);

// 4. stopOnError: false collects all rejections into an AggregateError in key order
await assert.rejects(
  () =>
    pMapKeyed(
      { first: 1, second: 2, third: 3 },
      async (value, key) => {
        if (key !== "second") {
          throw new Error(`fail:${key}`);
        }
        return value;
      },
      { concurrency: 2, stopOnError: false }
    ),
  (err) => {
    assert.ok(err instanceof AggregateError);
    assert.deepEqual(
      err.errors.map((e) => e.message),
      ["fail:first", "fail:third"]
    );
    return true;
  }
);