Creates a new observable
defines a callback to call when a new observer is added
Create a new Observer with the specified callback
the callback that will be executed for that Observer
the mask used to filter observers
if true the callback will be inserted at the first position, hence executed before the others ones. If false (default behavior) the callback will be inserted at the last position, executed after all the others already present.
optional scope for the callback to be called from
defines if the observer as to be unregistered after the next notification
the new observer created for the callback
Clear the list of observers
Clone the current observable
a new observable
Gets a boolean indicating if the observable has at least one observer
true is the Observable has at least one Observer registered
Does this observable handles observer registered with a given mask
defines the mask to be tested
whether or not one observer registered with the given mask is handeled
Notify a specific observer
defines the observer to notify
defines the data to be sent to each callback
is used to filter observers defaults to -1
Notify all Observers by calling their respective callback with the given data Will return true if all observers were executed, false if an observer set skipNextObservers to true, then prevent the subsequent ones to execute
defines the data to send to all observers
defines the mask of the current notification (observers with incompatible mask (ie mask & observer.mask === 0) will not be notified)
defines the original target of the state
defines the current target of the state
false if the complete observer chain was not processed (because one observer set the skipNextObservers to true)
Calling this will execute each callback, expecting it to be a promise or return a value. If at any point in the chain one function fails, the promise will fail and the execution will not continue. This is useful when a chain of events (sometimes async events) is needed to initialize a certain object and it is crucial that all callbacks will be executed. The order of the callbacks is kept, callbacks are not executed parallel.
The data to be sent to each callback
is used to filter observers defaults to -1
defines the callback target (see EventState)
defines he current object in the bubbling phase
will return a Promise than resolves when all callbacks executed successfully.
Remove a callback from the Observable object
the callback to remove
optional scope. If used only the callbacks with this scope will be removed
false if it doesn't belong to this Observable
Generated using TypeDoc
The Observable class is a simple implementation of the Observable pattern.
There's one slight particularity though: a given Observable can notify its observer using a particular mask value, only the Observers registered with this mask value will be notified. This enable a more fine grained execution without having to rely on multiple different Observable objects. For instance you may have a given Observable that have four different types of notifications: Move (mask = 0x01), Stop (mask = 0x02), Turn Right (mask = 0X04), Turn Left (mask = 0X08). A given observer can register itself with only Move and Stop (mask = 0x03), then it will only be notified when one of these two occurs and will never be for Turn Left/Right.