tiny-typed-emitter 2.1.0: TypedEmitter

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/tiny-typed-emitter@2.1.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/tiny-typed-emitter@2.1.0
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - 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:2e5cc637cfa5ac164c28fab8ea1d54eed30f92e4a1d5aa87ccd7e25d7f662d7b","constraints":{"executionContext":"node"},"contract":["TypedEmitter instantiates and emits typed events to registered listeners","TypedEmitter once method executes listener only on first emission","TypedEmitter prependListener and prependOnceListener add listeners to the start of the listener array","TypedEmitter off and removeListener unregister specific event callbacks","TypedEmitter removeAllListeners removes all listeners for an event or all events","TypedEmitter tracks listenerCount, eventNames, and listeners correctly","TypedEmitter setMaxListeners and getMaxListeners manage listener limits and return instance for chaining"],"goal":"verify pkg:npm/tiny-typed-emitter@2.1.0","kind":"HOW","packages":["pkg:npm/tiny-typed-emitter@2.1.0"],"schemaVersion":1,"symbols":["TypedEmitter"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/tiny-typed-emitter@2.1.0"],"schemaVersion":1,"subject":"pkg:npm/tiny-typed-emitter@2.1.0","symbols":["TypedEmitter"],"verifierAdapter":"node-typescript@1"}

{
  "name": "tiny-typed-emitter-verification",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "tiny-typed-emitter-verification",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "tiny-typed-emitter": "2.1.0"
      }
    },
    "node_modules/tiny-typed-emitter": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/tiny-typed-emitter/-/tiny-typed-emitter-2.1.0.tgz",
      "integrity": "sha512-qVtvMxeXbVej0cQWKqVSSAHmKZEHAvxdF8HEUBFWts8h+xEo5m/lEiPakuyZ3BnCBjOD8i24kzNOiOLLgsSxhA==",
      "license": "MIT"
    }
  }
}

{
  "name": "tiny-typed-emitter-verification",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification sample for tiny-typed-emitter",
  "type": "module",
  "main": "src/index.mjs",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "tiny-typed-emitter": "2.1.0"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/tiny-typed-emitter@2.1.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/tiny-typed-emitter@2.1.0"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

import { TypedEmitter } from 'tiny-typed-emitter';

/**
 * Creates a new instance of TypedEmitter.
 *
 * @returns {TypedEmitter} A new TypedEmitter instance.
 */
export function createEmitter() {
  return new TypedEmitter();
}

/**
 * Helper class that extends TypedEmitter for structured domain events.
 */
export class DomainEventEmitter extends TypedEmitter {
  constructor() {
    super();
  }
}

import assert from 'node:assert/strict';
import { TypedEmitter } from 'tiny-typed-emitter';
import { createEmitter, DomainEventEmitter } from '../src/index.mjs';

// 1. TypedEmitter instantiates and emits typed events to registered listeners
{
  const emitter = new TypedEmitter();
  const eventsReceived = [];

  emitter.on('message', (sender, text, timestamp) => {
    eventsReceived.push({ sender, text, timestamp });
  });

  const emitted = emitter.emit('message', 'Alice', 'Hello world', 1000);
  assert.strictEqual(emitted, true, 'emit should return true when listeners exist');
  assert.strictEqual(eventsReceived.length, 1);
  assert.deepStrictEqual(eventsReceived[0], {
    sender: 'Alice',
    text: 'Hello world',
    timestamp: 1000,
  });

  const noListenerEmitted = emitter.emit('unknownEvent');
  assert.strictEqual(noListenerEmitted, false, 'emit should return false when no listeners exist');
}

// 2. TypedEmitter once method executes listener only on first emission
{
  const emitter = createEmitter();
  let callCount = 0;
  let receivedVal = null;

  emitter.once('data', (val) => {
    callCount += 1;
    receivedVal = val;
  });

  emitter.emit('data', 42);
  assert.strictEqual(callCount, 1);
  assert.strictEqual(receivedVal, 42);

  emitter.emit('data', 100);
  assert.strictEqual(callCount, 1, 'once listener must not be called a second time');
  assert.strictEqual(emitter.listenerCount('data'), 0);
}

// 3. TypedEmitter prependListener and prependOnceListener add listeners to the start of the listener array
{
  const emitter = new TypedEmitter();
  const order = [];

  emitter.on('ping', () => {
    order.push('first-registered');
  });

  emitter.prependListener('ping', () => {
    order.push('prepended');
  });

  emitter.prependOnceListener('ping', () => {
    order.push('prepended-once');
  });

  emitter.emit('ping');
  assert.deepStrictEqual(order, ['prepended-once', 'prepended', 'first-registered']);

  order.length = 0;
  emitter.emit('ping');
  assert.deepStrictEqual(order, ['prepended', 'first-registered']);
}

// 4. TypedEmitter off and removeListener unregister specific event callbacks
{
  const emitter = new DomainEventEmitter();
  let received = 0;
  const listenerA = (x) => { received += x; };
  const listenerB = (x) => { received += x * 2; };

  emitter.on('add', listenerA);
  emitter.addListener('add', listenerB);

  emitter.emit('add', 5);
  assert.strictEqual(received, 15);

  emitter.off('add', listenerA);
  assert.strictEqual(emitter.listenerCount('add'), 1);

  emitter.emit('add', 2);
  assert.strictEqual(received, 19);

  emitter.removeListener('add', listenerB);
  assert.strictEqual(emitter.listenerCount('add'), 0);

  emitter.emit('add', 10);
  assert.strictEqual(received, 19);
}

// 5. TypedEmitter removeAllListeners removes all listeners for an event or all events
{
  const emitter = new TypedEmitter();
  emitter.on('ev1', () => {});
  emitter.on('ev1', () => {});
  emitter.on('ev2', () => {});

  assert.strictEqual(emitter.listenerCount('ev1'), 2);
  assert.strictEqual(emitter.listenerCount('ev2'), 1);

  emitter.removeAllListeners('ev1');
  assert.strictEqual(emitter.listenerCount('ev1'), 0);
  assert.strictEqual(emitter.listenerCount('ev2'), 1);

  emitter.removeAllListeners();
  assert.strictEqual(emitter.listenerCount('ev2'), 0);
  assert.strictEqual(emitter.eventNames().length, 0);
}

// 6. TypedEmitter tracks listenerCount, eventNames, and listeners correctly
{
  const emitter = new TypedEmitter();
  const fn1 = () => {};
  const fn2 = () => {};

  emitter.on('click', fn1);
  emitter.on('click', fn2);
  emitter.on('hover', fn1);

  assert.strictEqual(emitter.listenerCount('click'), 2);
  assert.strictEqual(emitter.listenerCount('hover'), 1);
  assert.strictEqual(emitter.listenerCount('nonexistent'), 0);

  const names = emitter.eventNames();
  assert.ok(names.includes('click'));
  assert.ok(names.includes('hover'));
  assert.strictEqual(names.length, 2);

  const clickListeners = emitter.listeners('click');
  assert.strictEqual(clickListeners.length, 2);
  assert.strictEqual(clickListeners[0], fn1);
  assert.strictEqual(clickListeners[1], fn2);

  const raw = emitter.rawListeners('click');
  assert.strictEqual(raw.length, 2);
}

// 7. TypedEmitter setMaxListeners and getMaxListeners manage listener limits and return instance for chaining
{
  const emitter = new TypedEmitter();
  const defaultMax = emitter.getMaxListeners();
  assert.strictEqual(typeof defaultMax, 'number');

  const chained = emitter.setMaxListeners(25);
  assert.strictEqual(chained, emitter, 'setMaxListeners should return emitter instance for chaining');
  assert.strictEqual(emitter.getMaxListeners(), 25);

  const chainedOn = emitter.on('test', () => {});
  assert.strictEqual(chainedOn, emitter, 'on should return emitter instance');
}

console.log('All tiny-typed-emitter contract assertions passed successfully.');