# nanoevent

> Type-safe event emitter for Node.js and Browser

Latest version **1.0.0** (published 2022-12-15) · ISC license · 0 weekly downloads

## Install

```sh
npm install nanoevent
pnpm add nanoevent
yarn add nanoevent
bun add nanoevent
```

## Health

**Score 30/100 (F)** — status: abandoned.

Positive: has types; esm support; no vulnerabilities; high quality score.

Warnings: low downloads.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.0.0 |
| Published | 2022-12-15 |
| First published | 2022-12-15 |
| Weekly downloads | 0 |
| License | ISC |
| TypeScript types | bundled |
| Module format | ESM + CommonJS |
| Dependencies | 0 |
| Unpacked size | 5.5 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 3 |
| Author | Boris Okunskiy |
| Maintainers | inca |
| Keywords | typed, event, emitter, typesafe, listener, handler |

## Links

- npm: https://www.npmjs.com/package/nanoevent
- Repository: https://github.com/NanoeventJS/nanoevent
- Homepage: https://github.com/NanoeventJS/nanoevent#readme
- Issues: https://github.com/NanoeventJS/nanoevent/issues
- npm.io page: https://npm.io/package/nanoevent

## Alternatives

- [async-exit-hook](https://npm.io/package/async-exit-hook.md) — 3.7M weekly downloads
- [evnty](https://npm.io/package/evnty.md) — 7.2K weekly downloads
- [eleventy-plugin-asciidoc](https://npm.io/package/eleventy-plugin-asciidoc.md) — 3.5K weekly downloads
- [@jswork/next-get2get](https://npm.io/package/@jswork/next-get2get.md) — 945 weekly downloads
- [@dashersw/axon](https://npm.io/package/@dashersw/axon.md) — 934 weekly downloads

## Recent versions

- 1.0.0 (latest) — 2022-12-15

## README

# Type-safe Event Emitter

Simple C#-style events (i.e. an emitter per event type).

```ts
interface ResizeEvent { oldSize: number, newSize: number }

const resized = new Event<ResizeEvent>();
resized.on(ev => console.log(`Resized from ${ev.oldSize} to ${ev.newSize}`));
resized.emit({ oldSize: 3, newSize: 5 });
```

## Highlights

- 🔥 Zero dependencies
- 🗜 Tidy and compact
- 💻 Works in browser
- 🔬 Strongly typed

## Usage

```ts
import { Event } from '@nodescript/event';

type Weather = 'sunny' | 'cloudy' | 'snowy';

interface WeatherChangedEvent {
    oldWeather: Weather;
    newWeather: Weather;
}

// The event object is created for each event type
const weatherChanged = new Event<WeatherChangedEvent>();

// Basic subscription: ev has type WeatherChangedEvent
weatherChanged.on(ev => {
    console.log(`Weather has changed from ${ev.oldWeather} to ${ev.newWeather}`);
});

// Basic emitting: the payload should have type WeatherChangedEvent
weatherChanged.emit({
    oldWeather: { /* ... */ },
    newWeather: { /* ... */ },
});

// Only-once subscription
weatherChanged.once(ev => console.log(`Weather has changed, but I won't bother you again`));

// .on and .once return an unsubscribe function
const unsubscribe = weatherChanged.on(ev => {
    if (isGoodWeather(ev.newWeather)) {
        console.log(`Finally, a good weather!`);
        unsubscribe();
    }
});
```

### Subscriber groups

You can use subscriber groups to quickly delete listeners.

This is especially useful if you use classes and do not want to store references to unsubscribe function returned by `on` and `once`.

```ts
// Subscriber groups can be used to quickly unsubscribe (super useful in classes!)
class SomeSubscriber {

    desiredWeather: Weather = 'sunny';

    subscribe() {
        // 1. Notice the second argument, `this` is our group identifier (can be anything except null)
        weatherChanged.on(ev => this.onWeatherChanged(ev), this);
    }

    onWeatherChanged(ev: WeatherChangedEvent) {
        if (ev.newWeather === this.desiredWeather) {
            console.log('Finally what we were waiting for!');
            // 2. Unsubscribe all listeners of group `this`
            weatherChanged.removeAll(this);
        }
    }
}
```

### Trivia

It is advisable to adopt a naming conventions for the events and payload types.

Also, it's often convenient to group all related events into a single "event bus":

```ts
import { Event } from '@nodescript/event';

class ChatEvents {
    roomCreated = new Event<Room>();
    roomDestroyed = new Event<Room>();
    message = new Event<Message>();
    personJoined = new Event<Person>();
    personLeft = new Event<Person>();
    personEntered = new Event<{ door: Door, person: Person }>();
}
```

---
_Source: https://npm.io/package/nanoevent · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._