mono-event is a minimal, type-safe single-event management library for JavaScript/TypeScript. It allows you to handle individual events with a straightforward API, similar to C# events, while keeping things lightweight and intuitive.

• Minimal API Easily add, remove, and emit events with a few function calls.
• Type-Safe Leverage TypeScript generics to ensure that event data types are checked at compile time.
• Balanced Performance Designed with a focus on balancing overall performance, memory usage, and bundle size, providing excellent results in practical use cases.
• Tiny Bundle Size Only 4.08 KB minified (1.05 KB gzipped), making it lightweight while maintaining full functionality.
• Synchronous / Asynchronous Support Choose between mono (synchronous) and monoAsync (asynchronous) versions. With monoAsync, you can control whether asynchronous listeners run sequentially or in parallel.
• Emission Control Separation With monoRestrict and monoRestrictAsync, you can separate the responsibilities of event registration (add/remove) and event emission, preventing accidental or unauthorized event firing.
• Flexible Listener Registration Register listeners with or without a caller context, and use the once option for one-time event handling.
• Comprehensive Listener Management Remove listeners by reference, by caller context, or remove all listeners at once.
• Direct Event Emitter Integration Use the .emitter property to easily integrate with existing event systems like DOM events.

You can install mono-event via npm or yarn:

npm install mono-event
# or
yarn add mono-event

bun add mono-event

// Import from npm
import {mono} from "npm:mono-event";

// Or import from URL
import {mono} from "https://esm.sh/mono-event";

import {mono} from 'mono-event';

const event = mono<string>();

// Register a listener (returns an unsubscribe function)
const unsubscribe = event.add((msg) => {
  console.log("Received:", msg);
});

// Register a listener with caller context
class MyHandler {
  value = '';

  handleEvent(msg: string) {
    this.value = msg;
    console.log("Handler received:", msg);
  }
}

const handler = new MyHandler();
event.add(handler, handler.handleEvent);

// Register a one-time listener
event.add((msg) => {
  console.log("One-time event:", msg);
}, {once: true});

// Emit an event
event.emit("Hello, world!");

// Unsubscribe using the returned function
unsubscribe();

// Or remove by reference
event.remove(handler, handler.handleEvent);

// Remove all listeners
event.removeAll();

// Using the emitter property with DOM events
const keydownEvent = mono<KeyboardEvent>();
window.addEventListener('keydown', keydownEvent.emitter);

// Later, to remove:
window.removeEventListener('keydown', keydownEvent.emitter);

For cases where asynchronous processing is required, use monoAsync. You can optionally choose between sequential (default) and parallel execution of async listeners.

import {monoAsync} from 'mono-event';

const asyncEvent = monoAsync<number>();

// Register an async listener
asyncEvent.add(async (num) => {
  await new Promise((resolve) => setTimeout(resolve, 1000));
  console.log("Processed:", num);
});

// Register with caller context
class AsyncProcessor {
  async process(num: number) {
    await new Promise((resolve) => setTimeout(resolve, 500));
    console.log("Processor received:", num);
  }
}

const processor = new AsyncProcessor();
asyncEvent.add(processor, processor.process);

// Register a one-time async listener
asyncEvent.add(async (num) => {
  console.log("One-time async:", num);
}, {once: true});

// Emit an event and wait for all listeners to finish
await asyncEvent.emit(42);

// Using parallel execution
const asyncEventParallel = monoAsync<number>({parallel: true});

When you want to clearly separate event registration from emission, use monoRestrict.

import {monoRestrict} from 'mono-event';

const {event, emit} = monoRestrict<string>();

// External code can register listeners using event.add()
event.add((msg) => {
  console.log("Restricted Received:", msg);
});

// With caller context
class Receiver {
  handleMessage(msg: string) {
    console.log("Receiver got:", msg);
  }
}

const receiver = new Receiver();
event.add(receiver, receiver.handleMessage);

// Remove listeners when needed
event.remove(receiver, receiver.handleMessage);
event.removeAll();

// Emission is performed via the emit() function
emit("Restricted Hello");

For async events with restricted emission, use monoRestrictAsync.

import {monoRestrictAsync} from 'mono-event';

const {event, emit} = monoRestrictAsync<number>();

event.add(async (num) => {
  await new Promise((resolve) => setTimeout(resolve, 500));
  console.log("Async Restricted:", num);
});

// With caller context and once option
class AsyncReceiver {
  async process(num: number) {
    await new Promise((resolve) => setTimeout(resolve, 300));
    console.log("AsyncReceiver processed:", num);
  }
}

const receiver = new AsyncReceiver();
event.add(receiver, receiver.process, {once: true});

await emit(123);

Utility functions are provided to easily apply common patterns like debouncing and throttling to your event handlers.

import { mono, monoDebounce, monoThrottle } from 'mono-event';

const event = mono<string>();
const waitMs = 500;

// Debounced handler: Executes only after 500ms of inactivity
const debouncedHandler = monoDebounce((data) => {
  console.log(`Debounced: ${data}`);
}, waitMs);

// Throttled handler: Executes at most once every 500ms (leading + trailing edge)
const throttledHandler = monoThrottle((data) => {
  console.log(`Throttled: ${data}`);
}, waitMs);

event.add(debouncedHandler);
event.add(throttledHandler);

// Example emissions
event.emit('A'); // Throttle executes immediately
event.emit('B');
setTimeout(() => event.emit('C'), 100);
// ... (Debounce executes after 500ms pause, Throttle executes trailing calls)

• Returns:
  • add(handler: (args: T) => void, options?: { once?: boolean }): () => void
  • add(caller: object, handler: (args: T) => void, options?: { once?: boolean }): () => void
  • remove(handler: (args: T) => void): boolean
  • remove(caller: object, handler: (args: T) => void): boolean
  • removeAll(): void
  • emit(args: T): void
  • emitter: (args: T) => void - A function property that calls emit with the provided argument. Useful for integrating with existing event systems.

• Options:
  • parallel: Determines whether async listeners run in parallel (true) or sequentially (false, default)
• Returns:
  • add(handler: (args: T) => Promise<void> | void, options?: { once?: boolean }): () => void
  • add(caller: object, handler: (args: T) => Promise<void> | void, options?: { once?: boolean }): () => void
  • remove(handler: (args: T) => Promise<void> | void): boolean
  • remove(caller: object, handler: (args: T) => Promise<void> | void): boolean
  • removeAll(): void
  • emit(args: T): Promise<void>
  • emitter: (args: T) => void - A function property that calls emit with the provided argument. Useful for integrating with existing event systems.

• Returns:
  • An object { event, emit } where:
    • event: An object with the following methods:
      • add(handler: (args: T) => void, options?: { once?: boolean }): () => void
      • add(caller: object, handler: (args: T) => void, options?: { once?: boolean }): () => void
      • remove(handler: (args: T) => void): boolean
      • remove(caller: object, handler: (args: T) => void): boolean
      • removeAll(): void
    • emit(args: T): void: A function dedicated to emitting events. This separation helps clearly define who is responsible for firing the event.

• Options:
  • parallel: Determines whether async listeners run in parallel (true) or sequentially (false, default)
• Returns:
  • An object { event, emit } where:
    • event: An object with the same methods as in monoRestrict, but supporting async handlers
    • emit(args: T): Promise<void>: A function dedicated to emitting events, returning a Promise that resolves when all handlers have completed.

• monoDebounce<F extends Function>(func: F, wait: number): F
  • Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked.
• monoThrottle<F extends Function>(func: F, wait: number): F
  • Creates a throttled function that only invokes func at most once per every wait milliseconds (leading + trailing edge behavior).

Contributions, feedback, and bug reports are welcome! Please see CONTRIBUTING.md for details on our code of conduct and the process for submitting pull requests.

mono-event is designed with a focus on balancing overall performance, memory usage, and bundle size, rather than pursuing the absolute fastest speed for specific operations. This approach provides excellent performance and a good developer experience in many practical use cases.

The latest benchmark results are as follows:

Note: nodeEvents and eventTarget results are only available in Node.js environment. Bundle size for Node.js built-ins is N/A. CV: Coefficient of Variation (lower is better, indicates stability).

You can find detailed performance benchmarks comparing mono-event with other popular event libraries (EventEmitter3, mitt, nanoevents, RxJS, Node Events, EventTarget) in the docs/performance directory.

Note: While mono-event aims for a good balance, each library has its own strengths. EventEmitter3 offers a familiar Node.js-like API, mitt and nanoevents prioritize minimal bundle size, and RxJS provides powerful reactive programming capabilities beyond simple event handling.

Benchmark Environment: Performance tests were conducted on macOS with an Apple M2 Ultra processor. Results are the average of 3 runs with the configurations specified in docs/performance/benchmark.js.

To run the benchmarks yourself:

# Install benchmark dependencies
npm install eventemitter3 mitt nanoevents rxjs --save-dev

# Build the library
npm run build

# Run benchmarks with Node.js (all scenarios)
node --expose-gc docs/performance/benchmark.js
# Or run specific scenarios by number (e.g., 7 for Emission, 11 for Comprehensive)
node --expose-gc docs/performance/benchmark.js 7 11

# Run benchmarks with Bun (all scenarios)
# Note: Memory results might be inaccurate in Bun due to GC differences.
bun --gc-expose docs/performance/benchmark.js
# Or run specific scenarios by number
bun --gc-expose docs/performance/benchmark.js 7 11

# Run benchmarks with Deno (all scenarios)
# Note: Memory results might be inaccurate in Deno due to GC differences.
# Requires network, read, and env permissions for dependencies and timing.
deno run --import-map deno.importmap.json --allow-net --allow-read --allow-env docs/performance/benchmark.js
# Or run specific scenarios by number
deno run --import-map deno.importmap.json --allow-net --allow-read --allow-env docs/performance/benchmark.js 7 11

Note: The benchmark dependencies are not included in the package by default to keep it lightweight.

This library is fully compatible with Bun and Deno. You can run the tests in each environment:

# Install Bun if you haven't already
curl -fsSL https://bun.sh/install | bash

# Run tests with Bun
npm run test:bun
# or directly
bun test bun.test.ts

# Install Deno if you haven't already
curl -fsSL https://deno.land/install.sh | sh

# Run tests with Deno
npm run test:deno
# or directly
deno test deno.test.ts --import-map=deno.importmap.json

mono-event was designed by yukimi-inu with coding assistance from Roo Code (Claude 3.7 Sonnet).

This project is licensed under the MIT License.