---
category: Utilities
---

# useEventBus

A basic event bus.

## Usage

```ts
import { useEventBus } from '@vueuse/core';

const bus = useEventBus<string>('news');

function listener(event: string) {
  console.log(`news: ${event}`);
}

// listen to an event
const unsubscribe = bus.on(listener);

// fire an event
bus.emit('The Tokyo Olympics has begun');

// unregister the listener
unsubscribe();
// or
bus.off(listener);

// clearing all listeners
bus.reset();
```

Listeners registered inside of components `setup` will be unregistered automatically when the component gets unmounted.

## TypeScript

Using `EventBusKey` is the key to bind the event type to the key, similar to Vue's [`InjectionKey`](https://antfu.me/posts/typed-provide-and-inject-in-vue) util.

```ts
// fooKey.ts
import type { EventBusKey } from '@vueuse/core';

export const fooKey: EventBusKey<{ name: foo }> = Symbol('symbol-key');
```

```ts
import { useEventBus } from '@vueuse/core';

import { fooKey } from './fooKey';

const bus = useEventBus(fooKey);

bus.on((e) => {
  // `e` will be `{ name: foo }`
});
```

## Type Declarations

```ts
export type EventBusListener<T = unknown, P = any> = (event: T, payload?: P) => void;
export type EventBusEvents<T, P = any> = Set<EventBusListener<T, P>>;
export interface EventBusKey<T> extends Symbol {}
export type EventBusIdentifier<T = unknown> = EventBusKey<T> | string | number;
export interface UseEventBusReturn<T, P> {
  /**
   * Subscribe to an event. When calling emit, the listeners will execute.
   * @param listener watch listener.
   * @returns a stop function to remove the current callback.
   */
  on: (listener: EventBusListener<T, P>) => Fn;
  /**
   * Similar to `on`, but only fires once
   * @param listener watch listener.
   * @returns a stop function to remove the current callback.
   */
  once: (listener: EventBusListener<T, P>) => Fn;
  /**
   * Emit an event, the corresponding event listeners will execute.
   * @param event data sent.
   */
  emit: (event?: T, payload?: P) => void;
  /**
   * Remove the corresponding listener.
   * @param listener watch listener.
   */
  off: (listener: EventBusListener<T>) => void;
  /**
   * Clear all events
   */
  reset: () => void;
}
export declare function useEventBus<T = unknown, P = any>(
  key: EventBusIdentifier<T>,
): UseEventBusReturn<T, P>;
```
