Typescript-observable NPM

typescript-observable

Adds classes and interfaces to make Typescript classes observable.

Installation

With npm

npm install --save typescript-observable

Observable

A class for observable objects.

on(type : string | string[], callback : (data : any) => void | IObserver) : { cancel : Function } Adds the observer callback to the event type. The returned object has a function cancel that removes the listener.
off(observer : IObserver) : boolean Removes the observer. Only works if the bound observer is of type IObserver. Returns true if the removal was successful, otherwise false.
count() : number Counts the number of observers.
clear() : void Removes all observers.
notify(event : IObservableEvent, data : any) : void Notifies all the observers listening to the IObservableEvent or any of its parents. The parameter data is passed to the observers.

ChangeObservable

extends Observable

A subclass of Observable that tracks changes.

hasChanged() : boolean Check if the object has changed.
setChanged() : void Set that the object has changed.
clearChanged

IObservableEvent

An interface for events.

parent : IObservableEvent Observers that observe the parent event will also be notified. Can be null.
name : string Name of the event.

IObserver

An interface that defines an observer.

update(data : any, name?: string) : void Called when the observers are notified.

Example

The class to be observed can be extended with Observable

let rootEvent : IObservableEvent = {
        parent: null,
        name: 'root'
    },
    childEvent : IObservableEvent = {
        parent: rootEvent,
        name: 'child'
    };

class TestObservable extends Observable {
  foo() : void {
    // do something
    // notify observers listening to the rootEvent
    notify(rootEvent, {
        message: 'rootEvent was called'
    });
  }

  bar() : void {
    // do something else
    // notify observers listening to the childEvent and the rootEvent
    notify(childEvent, {
        message: 'childEvent was called'
    });
  }
}

let testObservable = new TestObservable();

// Called on rootEvent and childEvent
testObservable.on('root', (data, name) => {
    console.log('root observer', data.message, name);
});

// Called on childEvent
testObservable.on('child', (data, name) => {
    console.log('child observer', data.message, name);
});

testObservable.foo();
/**
 * Prints:
 * root observer, rootEvent was called, root
 */

testObservable.bar();
/*
 * Prints:
 * root observer, childEvent was called, child
 * child observer, childEvent was called, child
 */