asynckit 0.4.0

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/asynckit@0.4.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/asynckit@0.4.0
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - 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:58b7191201b17593d8ac492bea1af3a6e7b9aded0ff53de6d3b711c5f83db0e7","constraints":{"executionContext":"node"},"contract":["parallel runs asynchronous tasks concurrently over an array and preserves result indexing","parallel runs asynchronous tasks concurrently over an object preserving keys","serial runs asynchronous tasks sequentially in order over an array","serial runs asynchronous tasks sequentially over an object","serialOrdered runs tasks in sequence ordered by ascending comparator","serialOrdered runs tasks in sequence ordered by descending comparator","error in task stops execution and returns partial results to callback"],"goal":"verify pkg:npm/asynckit@0.4.0","kind":"HOW","packages":["pkg:npm/asynckit@0.4.0"],"schemaVersion":1},"contractCommand":["node","test/contract.js"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/asynckit@0.4.0"],"schemaVersion":1,"subject":"pkg:npm/asynckit@0.4.0","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-asynckit",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-asynckit",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "asynckit": "0.4.0"
      }
    },
    "node_modules/asynckit": {
      "version": "0.4.0",
      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-asynckit",
  "version": "1.0.0",
  "description": "verify pkg:npm/asynckit@0.4.0",
  "main": "src/index.js",
  "scripts": {
    "test": "node test/contract.js"
  },
  "dependencies": {
    "asynckit": "0.4.0"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/asynckit@0.4.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/asynckit@0.4.0"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "runtime": "node@22.23.2"
  }
}

'use strict';

const asynckit = require('asynckit');

/**
 * Execute tasks in parallel.
 *
 * @param {Array|Object} list - Items to iterate over.
 * @param {Function} iterator - Asynchronous task worker function.
 * @param {Function} callback - Final completion callback.
 * @returns {Function} Terminator function to cancel pending tasks.
 */
function runParallel(list, iterator, callback) {
  return asynckit.parallel(list, iterator, callback);
}

/**
 * Execute tasks in series.
 *
 * @param {Array|Object} list - Items to iterate over.
 * @param {Function} iterator - Asynchronous task worker function.
 * @param {Function} callback - Final completion callback.
 * @returns {Function} Terminator function to cancel pending tasks.
 */
function runSerial(list, iterator, callback) {
  return asynckit.serial(list, iterator, callback);
}

/**
 * Execute tasks in sorted series order.
 *
 * @param {Array|Object} list - Items to iterate over.
 * @param {Function} iterator - Asynchronous task worker function.
 * @param {Function} sortMethod - Comparator function for ordering execution.
 * @param {Function} callback - Final completion callback.
 * @returns {Function} Terminator function to cancel pending tasks.
 */
function runSerialOrdered(list, iterator, sortMethod, callback) {
  return asynckit.serialOrdered(list, iterator, sortMethod, callback);
}

module.exports = {
  asynckit,
  parallel: asynckit.parallel,
  serial: asynckit.serial,
  serialOrdered: asynckit.serialOrdered,
  runParallel,
  runSerial,
  runSerialOrdered
};

'use strict';

const assert = require('assert');
const { asynckit, parallel, serial, serialOrdered, runParallel, runSerial, runSerialOrdered } = require('../src/index');

// 1. Module export verification
{
  assert.strictEqual(typeof asynckit.parallel, 'function');
  assert.strictEqual(typeof asynckit.serial, 'function');
  assert.strictEqual(typeof asynckit.serialOrdered, 'function');
  assert.strictEqual(typeof runParallel, 'function');
  assert.strictEqual(typeof runSerial, 'function');
  assert.strictEqual(typeof runSerialOrdered, 'function');
}

// 2. parallel runs asynchronous tasks concurrently over an array and preserves result indexing
function testParallelArray() {
  return new Promise((resolve, reject) => {
    const input = [1, 2, 3, 4];
    const completed = [];
    runParallel(input, (item, cb) => {
      setTimeout(() => {
        completed.push(item);
        cb(null, item * 10);
      }, (5 - item) * 5);
    }, (err, results) => {
      if (err) return reject(err);
      try {
        assert.deepStrictEqual(results, [10, 20, 30, 40]);
        assert.deepStrictEqual(completed, [4, 3, 2, 1]);
        resolve();
      } catch (e) {
        reject(e);
      }
    });
  });
}

// 3. parallel runs asynchronous tasks concurrently over an object preserving keys
function testParallelObject() {
  return new Promise((resolve, reject) => {
    const input = { alpha: 10, beta: 20 };
    parallel(input, (value, key, cb) => {
      setTimeout(() => {
        cb(null, `${key}:${value}`);
      }, 5);
    }, (err, results) => {
      if (err) return reject(err);
      try {
        assert.deepStrictEqual(results, { alpha: 'alpha:10', beta: 'beta:20' });
        resolve();
      } catch (e) {
        reject(e);
      }
    });
  });
}

// 4. serial runs asynchronous tasks sequentially in order over an array
function testSerialArray() {
  return new Promise((resolve, reject) => {
    const input = [1, 2, 3];
    const order = [];
    runSerial(input, (item, cb) => {
      setTimeout(() => {
        order.push(item);
        cb(null, item * 2);
      }, 5);
    }, (err, results) => {
      if (err) return reject(err);
      try {
        assert.deepStrictEqual(results, [2, 4, 6]);
        assert.deepStrictEqual(order, [1, 2, 3]);
        resolve();
      } catch (e) {
        reject(e);
      }
    });
  });
}

// 5. serial runs asynchronous tasks sequentially over an object
function testSerialObject() {
  return new Promise((resolve, reject) => {
    const input = { x: 1, y: 2 };
    const order = [];
    serial(input, (value, key, cb) => {
      order.push(key);
      cb(null, value + 5);
    }, (err, results) => {
      if (err) return reject(err);
      try {
        assert.deepStrictEqual(results, { x: 6, y: 7 });
        assert.deepStrictEqual(order, ['x', 'y']);
        resolve();
      } catch (e) {
        reject(e);
      }
    });
  });
}

// 6. serialOrdered runs tasks in sequence ordered by ascending comparator
function testSerialOrderedAscending() {
  return new Promise((resolve, reject) => {
    const input = [30, 10, 20];
    const order = [];
    runSerialOrdered(input, (item, cb) => {
      order.push(item);
      cb(null, item * 2);
    }, serialOrdered.ascending, (err, results) => {
      if (err) return reject(err);
      try {
        assert.deepStrictEqual(results, [60, 20, 40]);
        assert.deepStrictEqual(order, [10, 20, 30]);
        resolve();
      } catch (e) {
        reject(e);
      }
    });
  });
}

// 7. serialOrdered runs tasks in sequence ordered by descending comparator
function testSerialOrderedDescending() {
  return new Promise((resolve, reject) => {
    const input = [10, 30, 20];
    const order = [];
    serialOrdered(input, (item, cb) => {
      order.push(item);
      cb(null, item + 1);
    }, serialOrdered.descending, (err, results) => {
      if (err) return reject(err);
      try {
        assert.deepStrictEqual(results, [11, 31, 21]);
        assert.deepStrictEqual(order, [30, 20, 10]);
        resolve();
      } catch (e) {
        reject(e);
      }
    });
  });
}

// 8. error in task stops execution and returns partial results to callback
function testErrorTermination() {
  return new Promise((resolve, reject) => {
    const input = [1, 2, 3];
    serial(input, (item, cb) => {
      if (item === 2) {
        cb(new Error('task error'));
      } else {
        cb(null, item * 10);
      }
    }, (err, results) => {
      try {
        assert(err instanceof Error);
        assert.strictEqual(err.message, 'task error');
        assert.deepStrictEqual(results, [10]);
        resolve();
      } catch (e) {
        reject(e);
      }
    });
  });
}

async function runAll() {
  await testParallelArray();
  await testParallelObject();
  await testSerialArray();
  await testSerialObject();
  await testSerialOrderedAscending();
  await testSerialOrderedDescending();
  await testErrorTermination();
  console.log('All asynckit contract tests passed.');
}

runAll().catch((err) => {
  console.error(err);
  process.exit(1);
});