Strongly Typed Events

Add the power of events to your projects. We even have 3 flavors for you.


Event types

This project gives you the following event types:
- Events - styled after the way .Net implements events. With each event you'll get a sender and an argument object. If you use typescript, you can implement them using generics.
- Simple events - basically the same thing, with only 1 argument.
- Signals - for when no data is needed, just the firing of the event is enough.

$3

An example says more than a 1000 words. Imagine if you have events like this on your class:
``typescript
let clock = new Clock("Smu", 1000);

//log the ticks to the console - this is a signal event
clock.onTick.subscribe(() => console.log("Tick!"));

//log the sequence parameter to the console - this is a simple event
clock.onSequenceTick.subscribe(s => console.log(Sequence: ${s}));

//log the name of the clock and the tick argument to the console - this is an event
clock.onClockTick.subscribe((c, n) =>
console.log(${c.name} ticked ${n} times.)
);
`

$3

So let's look at the implementation from a TypeScript perspective. (Do you program NodeJs without typescript? Check this)

`typescript
import { SignalDispatcher, SimpleEventDispatcher, EventDispatcher } from "strongly-typed-events";

class Clock {
private _onTick = new SignalDispatcher();
private _onSequenceTick = new SimpleEventDispatcher();
private _onClockTick = new EventDispatcher();
private _ticks: number = 0;

constructor(public name: string, timeout: number) {
setInterval(() => {
this._ticks += 1;
this._onTick.dispatch();
this._onSequenceTick.dispatch(this._ticks);
this._onClockTick.dispatch(this, this._ticks);
}, timeout);
}

public get onTick() {
return this._onTick.asEvent();
}

public get onSequenceTick() {
return this._onSequenceTick.asEvent();
}

public get onClockTick() {
return this._onClockTick.asEvent();
}
}
`

$3

You can stop events from being propagated.

`typescript
let dispatcher = new SignalDispatcher();

let a = 0;
dispatcher.sub(ev => {
a++;
if (a > 2) {
ev.stopPropagation();
}
});

let b = 0;
dispatcher.sub(() => { b++; });

dispatcher.dispatch();
dispatcher.dispatch();
dispatcher.dispatch();
dispatcher.dispatch();

// a should be 4, because 4 dispatches are done.");
// b should be 2, because events after the 2nd dispatch are stopped."

`

Packages

The project is separated into multiple packages, so you only need
to include what you need. We have the following packages:

|Package|Description|
|-------|-----------|
|ste-core|Package that contains all the building blocks for the creation of events. The dispatcher implementation is its main hero.|
|ste-events or ste-promise-events|Events that are modeled after .Net with a sender and argument. If you use typescript, you can leverage the support for generics and get strongly typed code.|
|ste-simple-events or ste-promise-simple-events|A simpler version of the ste-event-event. No sender, just an argument.|
|ste-signals or ste-promise-signals|A signal is even simpler, it is just a callback for when you need to be alerted without any scope.|
|strongly-typed-events|This package includes everything.|
|ste-browser`|Helps to host events in the browser.|

Documentation

This project will help you to add events, event handling en event dispatching to your classes. To get you started, check:

- How to add an event to a class?
- How to add an event to an interface?
- How to add multiple events to a class?
- How to add dynamic named events to a class?
- How to do asynchronous event dispatching?
- On events, dispatchers and lists (a general explanation of the system)
- How to use Strongly Typed Events in Node.js?
- Some unsubscribe strategies

Check the documentation or the examples for more information.

History

The change history can be found here.

Maintenance

This project is maintained by Kees C. Bakker.