Class EventBus<TEvents>

EventBus class can be derived from any IEventBusAdapter.

IMPORT_PATH: "@daiso-tech/core/event-bus/implementations/derivables"

Type Parameters

Implements

Constructors

constructor

Methods

addListener addListenerMany asPromise dispatch dispatchMany getGroup listenOnce removeListener removeListenerMany subscribe subscribeMany withGroup

Constructors

constructor

Methods

addListener

  • addListener<TEventClass>(event, listener): LazyPromise<void>

  • Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}

    const listener: Invokable<AddEvent> = event => {
      console.log(event);
    }
    await eventBus.addListener(AddEvent, listener);
    await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));

addListenerMany

  • addListenerMany<TEventClass>(events, listener): LazyPromise<void>

  • Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}
    class SubEvent extends BaseEvent<{ c: number, d: number }> {}

    const listener: Invokable<AddEvent | SubEvent> = event => {
      console.log(event)
    }
    await eventBus.addListenerMany([AddEvent, SubEvent], listener);
    await eventBus.dispatchMany([
      new AddEvent({ a: 1, b: 2 }),
      new SubEvent({ c: 1, d: 2 }),
    ]);

asPromise

  • asPromise<TEventClass>(event): LazyPromise<EventInstance<TEventClass>>

  • Type Parameters

    Parameters

    Returns LazyPromise<EventInstance<TEventClass>>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}

    eventBus.asPromise(AddEvent).then(event => {
      console.log(event);
    });

    await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));

dispatch

  • dispatch(event): LazyPromise<void>

  • Parameters

    Returns LazyPromise<void>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}

    await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));

dispatchMany

  • dispatchMany(events): LazyPromise<void>

  • Parameters

    Returns LazyPromise<void>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}
    class SubEvent extends BaseEvent<{ c: number, d: number }> {}

    await eventBus.dispatchMany([
      new AddEvent({ a: 1, b: 2 }),
      new SubEvent({ c: 1, d: 2 }),
    ]);

getGroup

  • getGroup(): string

  • Returns string

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    // Will print "@global"
    console.log(eventBus.getGroup());

listenOnce

  • listenOnce<TEventClass>(event, listener): LazyPromise<void>

  • Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}

    await eventBus.listenOnce(AddEvent, event => {
      console.log(event);
    });

    await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));

removeListener

  • removeListener<TEventClass>(event, listener): LazyPromise<void>

  • Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}

    const listener: Invokable<AddEvent> = event => {
      console.log(event);
    }
    await eventBus.addListener(AddEvent, listener);
    await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));
    await eventBus.removeListener(AddEvent, listener);

removeListenerMany

  • removeListenerMany<TEventClass>(events, listener): LazyPromise<void>

  • Type Parameters

    Parameters

    Returns LazyPromise<void>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent, type Listener } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}
    class SubEvent extends BaseEvent<{ c: number, d: number }> {}

    const listener: Invokable<AddEvent | SubEvent> = event => {
      console.log(event);
    }
    await eventBus.addListenerMany([AddEvent, SubEvent], listener);
    await eventBus.dispatchMany([
      new AddEvent({ a: 1, b: 2 }),
      new SubEvent({ c: 1, d: 2 }),
    ]);
    await eventBus.removeListenerMany([AddEvent, SubEvent], listener);

subscribe

  • subscribe<TEventClass>(event, listener): LazyPromise<Unsubscribe>

  • Type Parameters

    Parameters

    Returns LazyPromise<Unsubscribe>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}

    const unsubscribe = await eventBus.subscribe(AddEvent, event => {
      console.log(event);
    });
    await eventBus.dispatch(new AddEvent({ a: 1, b: 2,}));
    await unsubscribe();

subscribeMany

  • subscribeMany<TEventClass>(events, listener): LazyPromise<Unsubscribe>

  • Type Parameters

    Parameters

    Returns LazyPromise<Unsubscribe>

    Example

    import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    class AddEvent extends BaseEvent<{ a: number, b: number }> {}
    class SubEvent extends BaseEvent<{ c: number, d: number }> {}

    const unsubscribe = await eventBus.subscribeMany([AddEvent, SubEvent], event => {
      console.log(event);
    });
    await eventBus.dispatchMany([
      new AddEvent({ a: 1, b: 2 }),
      new SubEvent({ c: 1, d: 2 }),
    ]);
    await unsubscribe();

withGroup

  • withGroup(group): IEventBus<TEvents>

  • Parameters

    Returns IEventBus<TEvents>

    Example

    import type { IGroupableEventBus, IEventBus } from "@daiso-tech/core/event-bus/contracts";
    import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
    import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
    import { BaseEvent } from "@daiso-tech/core/event-bus/contracts";

    const eventBus: IGroupableEventBus = new EventBus({
      adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
    });

    // Will print "@global"
    console.log(eventBus.getGroup());

    const groupedEventBus: IEventBus = eventBus.withGroup("company-1");

    // Will print "@global/company-1"
    console.log(groupedEventBus.getGroup());

Settings

Member Visibility

On This Page

Constructors
Methods