cozyevent

CozyEvent — World's fastest, Lightweight Event Emitter also for React

A lightweight ; only 341 Bytes (bundle size), might be the worlds fastest, microtask-based asynchronous and synchronous event emitter for JavaScript/TypeScript. Also for REACT! Check the benchmark results below!

Whats COZY stands for;

COZY stands for Compact, On-point, Zero-overhead, Yet-powerful.

A fine-tailored ecosystem of TypeScript libraries designed for your everyday needs—lightweight, efficient, and built to get the job done. No bloat, just pure performance. 🚀

Change log

• v.1.4.0: React Support; CozyEvent has now react support! (Special thanks to jeangq24 )
• v.1.2.0: Performance improvement; 22x faster than v.1.1.0 (see the benchmark below)
• v1.1.0: Performance improvement; 4x faster than version v1.0 (see the benchmark bellow)

Features

• Supports both synchronous and asynchronous (microtask-based) event emission.
• Allows multiple listeners per event.
• Provides once event handling.
• Enables removal of specific or all event listeners.
• Designed for performance with a minimal footprint.

Installation

You can install CozyEvent via npm or yarn:

Light version - non react (only 341 Bytes)

npm install cozyevent@latest-light

or

yarn add cozyevent@latest-light

Or With React supported version

npm install cozyevent

or

yarn add cozyevent

Usage

Importing CozyEvent

ESModule

import { CozyEvent } from 'cozyevent';

CommonJS

const { CozyEvent } = require('cozyevent');

Creating an Event Emitter

const eventEmitter = new CozyEvent();

Registering Event Handlers

on(event: string, handler: EventHandler): void

Registers an event listener that triggers every time the event is emitted.

eventEmitter.on('message', (msg) => {
  console.log(`Received: ${msg}`);
});

once(event: string, handler: EventHandler): void

Registers an event listener that triggers only once.

eventEmitter.once('init', () => {
  console.log('Initialization complete!');
});

Emitting Events

emit(event: string, ...args: any[]): void

Emits a sync event.

eventEmitter.emit('message', 'Hello, World!');

emitAsync(event: string, ...args: any[]): void

Emits an async event emission using microtasks.

eventEmitter.emitAsync('data', { id: 1, name: 'John Doe' });

Removing Event Listeners

off(event: string, handler: EventHandler): void

Removes a specific event listener.

const handler = (msg) => console.log(msg);
eventEmitter.on('chat', handler);
eventEmitter.off('chat', handler);

removeAllListeners(event?: string): void

Removes all listeners for a specific event or all events if no event is specified. This method replaces the previous destroy method, as it now handles the same functionality.

eventEmitter.removeAllListeners('chat');

Extending CozyEvent

You can extend CozyEvent in your own class to create a custom event-driven system:

class SomeClass extends CozyEvent {
  doSomething() {
    console.log('Doing something...');
    this.emit('done', 'Task completed');
  }
}

const instance = new SomeClass();
instance.on('done', (message) => {
  console.log(`Received: ${message}`);
});

instance.doSomething();

Destroying the Event Emitter (Deprecated)

destroy(): void

Deprecated: This method has been replaced by removeAllListeners(). Use removeAllListeners() to achieve the same functionality.

// Deprecated
eventEmitter.destroy();

// Recommended
eventEmitter.removeAllListeners();

CozyEvent React Integration

CozyEvent provides seamless React integration through:

• CozyEventProvider (Context Provider)
• useCozyEvent (Custom Hook)
• Centralized Instance Registry

This allows declarative event management in React applications, supporting multiple instances and automatic event cleanup.

Installation

npm install cozyevent

or

yarn add cozyevent

Components & Hooks

CozyEventProvider

A React context provider that supplies a CozyEvent instance to child components.

Props:

• instance?: Custom CozyEvent instance (defaults to global instance).
• children: Child components with event access.
• id?: Identifier for managing multiple instances (default: 'default').

Example:

import { CozyEventProvider } from 'cozyevent';

const App = () => (
  <CozyEventProvider>
    <MyComponent />
  </CozyEventProvider>
);

useCozyEvent

A hook for subscribing to events from the nearest CozyEventProvider.

Parameters:

• eventName: Event name (required).
• callback: Function executed when the event is emitted (required).
• options?:
  • namespace?: Scope event subscription.
  • id?: Target a specific CozyEventProvider.

Returns:

• CozyEvent instance.

Example:

import { useCozyEvent } from 'cozyevent';

const EventListener = () => {
  useCozyEvent('message', (data) => {
    console.log('Received:', data);
  });

  return <div>Listening...</div>;
};

Centralized Instance Registry

Manages multiple CozyEvent instances globally.

registerCozyEventInstance(id: string, instance: CozyEvent)

Registers an instance.

Note: You don't need to manually register the instance before creating the CozyEventProvider. The provider will automatically register the instance with the given id.

import { registerCozyEventInstance, CozyEvent } from 'cozyevent';

const emitter = new CozyEvent();
registerCozyEventInstance('custom', emitter);

getCozyEventInstanceById(id: string): CozyEvent | undefined

Retrieves an instance.

import { getCozyEventInstanceById } from 'cozyevent';

const emitter = getCozyEventInstanceById('custom');
emitter?.emit('event', 'Hello!');

Usage Examples

Basic Usage

import React from 'react';
import { CozyEventProvider, useCozyEvent } from 'cozyevent';

const EventEmitter = () => {
  const emitEvent = () => {
    getCozyEventInstanceById('default')?.emit('test-event', 'Hello!');
  };
  return <button onClick={emitEvent}>Emit Event</button>;
};

const EventListener = () => {
  useCozyEvent('test-event', (message) => alert(message));
  return <div>Listening for events...</div>;
};

const App = () => (
  <CozyEventProvider>
    <EventEmitter />
    <EventListener />
  </CozyEventProvider>
);

export default App;

Using Namespaces

useCozyEvent('user-login', (data) => console.log('Logged in:', data), {
  namespace: 'auth',
});

Multiple Instances

const App = () => (
  <>
    <CozyEventProvider id="auth">
      <AuthModule />
    </CozyEventProvider>
    <CozyEventProvider id="notifications">
      <NotificationModule />
    </CozyEventProvider>
  </>
);

const AuthModule = () => {
  useCozyEvent('login', (data) => console.log('User:', data), { id: 'auth' });
  return <div>Auth Module</div>;
};

const NotificationModule = () => {
  useCozyEvent('new-message', (msg) => console.log('Message:', msg), {
    id: 'notifications',
  });
  return <div>Notifications</div>;
};

Global Instance Fallback

If CozyEventProvider is missing, useCozyEvent falls back to the global instance.

useCozyEvent('global-event', (data) => console.log('Global event:', data));

Best Practices

✅ Use meaningful event names to avoid conflicts.
✅ Leverage namespaces for better organization.
✅ Let useCozyEvent handle cleanup (no manual unsubscriptions).
✅ Use custom instances for modularity.
✅ Assign id to providers for debugging.
✅ Utilize the registry for easy instance management.

Benchmark Results

Emit:

The following are the benchmark results for 1,000,000 listeners (from fastest to slowest):

Library	Operation	Rate (ops/sec)	Variability (%)	Runs Sampled
cozyEvent	emit	4,095	±0.80%	94
tseep	emit	3,587	±1.85%	91
braintree-event-emitter	emit	3,431	±3.43%	85
emitix	emit	461	±2.41%	84
eventemitter3	emit	180	±1.89%	83
eventemitter2	emit	150	±2.45%	76
node-event-emitter	emit	120	±4.22%	70
protobufjs-eventemitter	emit	119	±0.70%	77
event-emitter	emit	91.98	±3.25%	68

On:

Library	ops/sec	Variability (%)	Runs Sampled
cozyEvent	7,048,823	±23.01%	44
tseep	6,699,486	±22.93%	58
eventemitter2	4,759,473	±32.42%	48
eventemitter3	2,760,536	±34.21%	47
braintree-event-emitter	2,493,323	±25.56%	34
event-emitter	1,578,055	±29.92%	35
protobufjs-eventemitter	1,533,468	±62.37%	18
emitix	886,668	±65.42%	20
node-event-emitter	116,289	±12.12%	18

Once:

Library	ops/sec	Variability (%)	Runs Sampled
tseep	7,025,903	±19.21%	49
cozyEvent	3,161,190	±36.82%	35
eventemitter2	2,349,562	±28.37%	42
eventemitter3	2,247,466	±32.67%	42
event-emitter	293,539	±115.29%	17
node-event-emitter	69,743	±77.57%	18
emitix	27,619	±50.74%	6

Off:

Library	ops/sec	Variability (%)	Runs Sampled
tseep	241,358,834	±0.43%	96
eventemitter3	237,546,830	±0.78%	90
emitix	86,382,491	±1.77%	93
protobufjs-eventemitter	84,816,381	±0.54%	99
cozyEvent	64,156,580	±1.30%	89
node-event-emitter	53,750,923	±2.40%	91
eventemitter2	47,492,910	±1.99%	86
braintree-event-emitter	37,476,993	±0.49%	96
event-emitter	34,195,978	±0.99%	96

RemoveAllListeners

Library	ops/sec	Variability (%)	Runs Sampled
cozyEvent	174,527,998	±0.86%	89
eventemitter3	160,803,376	±2.56%	91
eventemitter2	104,917,857	±2.26%	94
node-event-emitter	26,451,753	±3.37%	90
tseep	8,722,096	±2.12%	93

License

Copyright (c) 2025 Mehmet Ergin Turk

Licensed under the MIT license. See the LICENSE file for details.

(Twitter/x: @papa_alpha_papa),

(Mastodon: @papa_alpha_papa)

(Bluesky: @erginturk.bsky.social)