/**
* @module proact-core
*/
/**
* <p>
* `ProAct.Actor` is the basic observer-observable functionallity in ProAct.js
* </p>
* <p>
* The actors in ProAct.js form the dependency graph.
* If some actor listens to changes from another - it depends on it.
* </p>
* <p>
* The actors can transform the values or events incoming to them.
* </p>
* <p>
* Every actor can have a parent actor, that will be notified for all the changes
* on the child-actor, it is something as special observer.
* </p>
* <p>
* ProAct.Actor is part of the core module of ProAct.js.
System.out.println();
* </p>
*
* @class ProAct.Actor
* @constructor
* @param {String} [queueName]
* The name of the queue all the updates should be pushed to.
* <p>
* If this parameter is null/undefined the default queue of
* {{#crossLink "ProAct/flow:property"}}{{/crossLink}} is used.
* </p>
* <p>
* If this parameter is not a string it is used as the
* <i>transforms</i>.
* </p>
* @param {Array} [transforms]
* A list of transformation to be used on all incoming chages.
*/
function Actor (queueName, transforms) {
if (queueName && !P.U.isString(queueName)) {
transforms = queueName;
queueName = null;
}
P.U.defValProp(this, 'listeners', false, false, true, this.defaultListeners());
P.U.defValProp(this, 'listener', false, false, true, null);
P.U.defValProp(this, 'errListener', false, false, true, null);
P.U.defValProp(this, 'closeListener', false, false, true, null);
P.U.defValProp(this, 'parent', false, false, true, null);
P.U.defValProp(this, 'queueName', false, false, false, queueName);
P.U.defValProp(this, 'transforms', false, false, true,
(transforms ? transforms : []));
P.U.defValProp(this, 'state', false, false, true, P.States.init);
this.init();
}
ProAct.Actor = P.Pro = Actor;
P.U.ex(P.Actor, {
/**
* A constant defining bad values or bad events.
*
* Part of the filtering mechainsm; If a transformation returns
* a `BadValue`, based on uncomming event -> the event is skipped.
*
* @property BadValue
* @type Object
* @final
* @static
* @for ProAct.Actor
*/
BadValue: {},
/**
* A constant defining closing or ending events.
*
* If a transformation returns this value, the actor will be closed.
*
* You can manually close `Actor`s updating them with this constant as an event.
*
* @property Close
* @type Object
* @final
* @static
* @for ProAct.Actor
*/
Close: {},
/**
* Transforms the passed <i>val</i> using the {{#crossLink "ProAct.Actor/transforms:method"}}{{/crossLink}} method of the passed <i>actor</i>.
*
* @method transforms
* @for ProAct.Actor
* @static
* @param {ProAct.Actor} actor The `ProAct.Actor` which transformations should be used.
* @param {Object} val The value to transform.
* @return {Object} The transformed value.
*/
transform: function (actor, val) {
var i, t = actor.transforms, ln = t.length;
for (i = 0; i < ln; i++) {
val = t[i].call(actor, val);
if (val === P.Actor.BadValue) {
break;
}
if (val === P.Actor.Close) {
break;
}
}
return val;
}
});
P.Actor.prototype = {
/**
* Reference to the constructor of this object.
*
* @property constructor
* @type ProAct.Actor
* @final
* @for ProAct.Actor
*/
constructor: ProAct.Actor,
/**
* Initializes this actor.
* <p>
* This method logic is run only if the current state of <i>this</i> is
* {{#crossLink "ProAct.States/init:property"}}{{/crossLink}}.
* </p>
* <p>
* Then {{#crossLink "ProAct.Actor/afterInit:method"}}{{/crossLink}} is called to finish the initialization.
* </p>
*
* @for ProAct.Actor
* @instance
* @method init
*/
init: function () {
if (this.state !== P.States.init) {
return;
}
this.doInit();
this.afterInit();
},
/**
* Allocating of resources or initializing is done here.
* <p>
* Empty by default.
* </p>
*
* @for ProAct.Actor
* @instance
* @protected
* @method doInit
*/
doInit: function () {},
/**
* Called automatically after initialization of this actor.
* <p>
* By default it changes the state of <i>this</i> to {{#crossLink "ProAct.States/ready:property"}}{{/crossLink}}.
* </p>
* <p>
* It can be overridden to define more complex initialization logic.
* </p>
*
* @for ProAct.Actor
* @instance
* @protected
* @method afterInit
*/
afterInit: function () {
this.state = P.States.ready;
},
/**
* Closes this actor => it state becomes {{#crossLink "ProAct.States/closed:property"}}{{/crossLink}}.
*
* This sends a `close` event to all the subscribers to closing.
*
* After closing the actor it can't emit events anymore.
*
* Example:
* ```
* var actor = new ProAct.Actor();
* actor.onClose(function () {
* console.log('Done!');
* });
*
* actor.close(); // We will see 'Done!' on the console output.
* ```
*
* @for ProAct.Actor
* @instance
* @method close
* @return {ProAct.Actor} This instance - can be chained.
*/
close: function () {
if (this.state === P.States.closed) {
return;
}
return ActorUtil.update.call(this, P.Actor.Close, 'close');
},
/**
* Checks if <i>this</i> can be closed.
* <p>
* Defaults to return true.
* </p>
*
* @for ProAct.Actor
* @protected
* @instance
* @method canClose
*/
canClose: function () {
return true;
},
/**
* This method is called when a `close` event is pushed to this `Actor`.
*
* It removes all the subscriptions to the `Actor` and sets its
* state to {{#crossLink "ProAct.States/closed:property"}}{{/crossLink}}.
*
* Do not call this method; it is private!
*
* @for ProAct.Actor
* @private
* @instance
* @protected
* @method doClose
*/
doClose: function () {
this.state = P.States.closed;
this.offAll();
if (this.listener) {
this.listener.closed = true;
}
},
/**
* Called immediately before destruction.
*
* The idea is to be implemented by extenders to free additional resources on destroy.
*
* @for ProAct.Actor
* @instance
* @abstract
* @protected
* @method beforeDestroy
*/
beforeDestroy: function () {
},
/**
* Destroys this `ProAct.Actor` instance.
* <p>
* The state of <i>this</i> is set to {{#crossLink "ProAct.States/destroyed:property"}}{{/crossLink}}.
* </p>
*
* Calls {{#crossLink "ProAct.Actor/beforeDestroy:method"}}{{/crossLink}}
*
* @for ProAct.Actor
* @instance
* @method destroy
*/
destroy: function () {
if (this.state === P.States.destroyed) {
return;
}
this.beforeDestroy();
this.listeners = undefined;
if (this.listener) {
this.listener.destroyed = true;
}
this.listener = undefined;
this.errListener = undefined;
this.closeListener = undefined;
this.parent = undefined;
this.queueName = undefined;
this.transforms = undefined;
this.state = P.States.destroyed;
},
/**
* Generates the initial listeners object.
* It can be overridden for alternative listeners collections.
* It is used for resetting all the listeners too.
*
* The default types of listeners are:
* ```
* {
* change: [],
* error: [],
* close: []
* }
* ```
*
* @for ProAct.Actor
* @instance
* @protected
* @method defaultListeners
* @return {Object} A map containing the default listeners collections.
*/
defaultListeners: function () {
return {
change: [],
error: [],
close: []
};
},
/**
* A list of actions or action to be used when no action is passed for the methods working with actions.
*
* @for ProAct.Actor
* @instance
* @method defaultActions
* @protected
* @default 'change'
* @return {Array|String} The actions to be used if no actions are provided to action related methods, like
* {{#crossLink "ProAct.Actor/on:method"}}{{/crossLink}},
* {{#crossLink "ProAct.Actor/off:method"}}{{/crossLink}},
* {{#crossLink "ProAct.ActorUtil/update:method"}}{{/crossLink}}.
*/
defaultActions: function () {
return 'change';
},
/**
* Creates the <i>listener</i> of this actor.
*
* Every actor should have one listener that should pass to other actors.
*
* <p>
* This listener turns the actor in a observer.
* </p>
* <p>
* Should be overriden with specific listener, by default it returns {{#crossLink "ProAct/N:method"}}{{/crossLink}}.
* </p>
*
* @for ProAct.Actor
* @instance
* @abstract
* @method makeListener
* @protected
* @default {ProAct.N}
* @return {Object} The <i>listener of this observer</i>.
*/
makeListener: P.N,
/**
* Creates the <i>error listener</i> of this actor.
*
* Every actor should have one error listener that should pass to other actors.
*
* <p>
* This listener turns the actor in a observer for errors.
* </p>
* <p>
* Should be overriden with specific listener, by default it returns {{#crossLink "ProAct/N:method"}}{{/crossLink}}.
* </p>
*
* @for ProAct.Actor
* @instance
* @abstract
* @method makeErrListener
* @protected
* @default {ProAct.N}
* @return {Object} The <i>error listener of this observer</i>.
*/
makeErrListener: P.N,
/**
* Creates the <i>closing listener</i> of this actor.
*
* Every actor should have one closing listener that should pass to other actors.
*
* <p>
* This listener turns the actor in a observer for closing events.
* </p>
* <p>
* Should be overriden with specific listener, by default it returns {{#crossLink "ProAct/N:method"}}{{/crossLink}}.
* </p>
*
* @for ProAct.Actor
* @instance
* @abstract
* @protected
* @method makeCloseListener
* @default {ProAct.N}
* @return {Object} The <i>closing listener of this observer</i>.
*/
makeCloseListener: P.N,
/**
* Creates the <i>event</i> to be send to the listeners on update.
*
* <p>
* The <i>event</i> should be an instance of {{#crossLink "ProAct.Event"}}{{/crossLink}}.
* </p>
*
* <p>
* By default this method returns {{#crossLink "ProAct.Event.Types/value:property"}}{{/crossLink}} event.
* </p>
*
* @for ProAct.Actor
* @instance
* @method makeEvent
* @default {ProAct.Event} with type {{#crossLink "ProAct.Event.Types/value:property"}}{{/crossLink}}.
* @protected
* @param {ProAct.Event} source The source event of the event. It can be null
* @return {ProAct.Event} The event.
*/
makeEvent: function (source) {
return new P.Event(source, this, P.Event.Types.value);
},
/**
* Attaches a new listener to this `ProAct.Actor`.
*
* The listener may be function or object that defines a <i>call</i> method.
*
* ```
* actor.on(function (v) {
* console.log(v);
* });
*
* actor.on('error', function (v) {
* console.error(v);
* });
*
* actor.on({
* call: function (v) {
* console.log(v);
* }
* });
* ```
*
* @for ProAct.Actor
* @instance
* @method on
* @param {Array|String} actions
* The action/actions to listen for. If this parameter is skipped or null/undefined,
* the actions from {{#crossLink "ProAct.Actor/defaultActions:method"}}{{/crossLink}} are used.
* <p>
* The actions can be skipped and on their place as first parameter to be passed the <i>listener</i>.
* </p>
* @param {Object} listener
* The listener to attach. It must be instance of Function or object with a <i>call</i> method.
* @return {ProAct.Actor}
* <b>this</b>
*/
on: function (actions, listener) {
if (!P.U.isString(actions) && !P.U.isArray(actions)) {
listener = actions;
actions = this.defaultActions();
}
if (!P.U.isArray(actions)) {
actions = [actions];
}
var ln = actions.length,
action, i, listeners;
for (i = 0; i < ln; i ++) {
action = actions[i];
listeners = this.listeners[action];
if (!listeners) {
listeners = this.listeners[action] = [];
}
listeners.push(listener);
}
return this;
},
/**
* Removes a <i>listener</i> from the passed <i>action</i>.
*
* <p>
* If this method is called without parameters, all the listeners for all the actions are removed.
* The listeners are reset using {{#crossLink "ProAct.Actor/defaultActions:method"}}{{/crossLink}}.
* </p>
*
* Examples are:
*
* Removing a listener:
* ```
* var listener = function (v) {
* console.log(v);
* };
* actor.on(listener);
* actor.off(listener);
* ```
*
* Or for removing all the listeners attached to an actor:
* ```
* actor.off();
* ```
*
* Or for removing all the listeners of a given type attached to an actor:
* ```
* actor.off('error');
* ```
*
* Or for removing a listener from different type of actions:
* ```
* var listener = function (v) {
* console.log(v);
* };
* actor.on(listener);
* actor.onErr(listener);
*
* actor.off(['error', 'change'], listener);
* ```
*
* @for ProAct.Actor
* @instance
* @method off
* @param {Array|String} actions
* The action/actions to stop listening for. If this parameter is skipped or null/undefined,
* the actions from {{#crossLink "ProAct.Actor/defaultActions:method"}}{{/crossLink}} are used.
* <p>
* The actions can be skipped and on their place as first parameter to be passed the <i>listener</i>.
* </p>
* @param {Object} listener
* The listener to detach. If it is skipped, null or undefined all the listeners are removed from this actor.
* @return {ProAct.Actor}
* <b>this</b>
*/
off: function (actions, listener) {
if (!actions && !listener) {
this.listeners = this.defaultListeners();
return this;
}
if (!P.U.isString(actions) && !P.U.isArray(actions)) {
listener = actions;
actions = this.defaultActions();
}
if (!P.U.isArray(actions)) {
actions = [actions];
}
var ln = actions.length,
action, i, listeners;
for (i = 0; i < ln; i ++) {
action = actions[i];
listeners = this.listeners[action];
if (listeners) {
P.U.remove(listeners, listener);
}
}
return this;
},
/**
* Attaches a new error listener to this ProAct.Actor.
*
* The listener may be function or object that defines a <i>call</i> method.
*
* This is the same as calling `on('error', listener)` on an `Actor`...
*
* @for ProAct.Actor
* @instance
* @method onErr
* @param {Object} listener
* The listener to attach. It must be instance of Function or object with a <i>call</i> method.
* @return {ProAct.Actor}
* <b>this</b>
*/
onErr: function (listener) {
return this.on('error', listener);
},
/**
* Removes an error <i>listener</i> from the passed <i>action</i>.
*
* This is the same as calling `off('error', listener)` on an `Actor`...
*
* @for ProAct.Actor
* @instance
* @method offErr
* @param {Object} listener
* The listener to detach. If it is skipped, null or undefined all the listeners are removed from this actor.
* @return {ProAct.Actor}
* <b>this</b>
*/
offErr: function (listener) {
return this.off('error', listener);
},
/**
* Attaches a new close notifcation listener to this `ProAct.Actor`.
*
* The listener may be function or object that defines a <i>call</i> method.
*
* This is the same as calling `on('close', listener)` on an `Actor`...
*
* @for ProAct.Actor
* @instance
* @method onClose
* @param {Object} listener
* The listener to attach. It must be instance of Function or object with a <i>call</i> method.
* @return {ProAct.Actor}
* <b>this</b>
*/
onClose: function (listener) {
return this.on('close', listener);
},
/**
* Removes a close notification <i>listener</i> from the passed <i>action</i>.
*
* This is the same as calling `off('close', listener)` on an `Actor`...
*
* @for ProAct.Actor
* @instance
* @method offClose
* @param {Object} listener
* The listener to detach. If it is skipped, null or undefined all the listeners are removed from this actor.
* @return {ProAct.Actor}
* <b>this</b>
*/
offClose: function (listener) {
return this.off('close', listener);
},
/**
* Attaches the passed listener to listen to values, errors and the close notification from this `ProAct.Actor`.
*
* The listener may be function or object that defines a <i>call</i> method.
*
* @for ProAct.Actor
* @instance
* @method onAll
* @param {Object} listener
* The listener to attach. It must be instance of Function or object with a <i>call</i> method.
* @return {ProAct.Actor}
* <b>this</b>
*/
onAll: function (listener) {
return this.on(listener).onClose(listener).onErr(listener);
},
/**
* Removes all notifications <i>listener</i> from the passed <i>action</i>.
*
* @for ProAct.Actor
* @instance
* @method offAll
* @param {Object} listener
* The listener to detach. If it is skipped, null or undefined all the listeners are removed from this actor.
* @return {ProAct.Actor}
* <b>this</b>
*/
offAll: function (listener) {
this.off(listener);
this.off('error', listener);
return this.off('close', listener);
},
/**
* Links source actors into this actor. This means that <i>this actor</i>
* is listening for changes from the <i>sources</i>.
* <p>
* A good example is one stream to have another as as source -> if data comes into the source
* stream, it is passed to the listening too. That way the source stream is plugged <b>into</b> the listening one.
* </p>
* <p>
* The listeners from {{#crossLink "ProAct.Actor/makeListener:method"}}{{/crossLink}},
* {{#crossLink "ProAct.Actor/makeErrListener:method"}}{{/crossLink}} and {{#crossLink "ProAct.Actor/makeCloseListener:method"}}{{/crossLink}} are used.
* </p>
*
* Chaining actors is very powerful operation. It can be used to merge many source actors into one.
*
* ```
* var sourceActor1 = <Actor implementation>;
* var sourceActor2 = <Actor implementation>;
* var actor = <Actor implementation>;
*
* actor.into(sourceActor1, sourceActor2);
* actor.on(function (v) {
* console.log(v);
* });
*
* ```
*
* Now if the any of the source actors is updated, the update will be printed on the console by the `actor`.
*
* @for ProAct.Actor
* @instance
* @method into
* @param [...]
* Zero or more source ProAct.Actors to set as sources.
* @return {ProAct.Actor}
* <b>this</b>
*/
into: function () {
var args = slice.call(arguments),
ln = args.length, i, source;
for (i = 0; i < ln; i++) {
source = args[i];
source.on(this.makeListener());
source.onErr(this.makeErrListener());
source.onClose(this.makeCloseListener());
}
return this;
},
/**
* The reverse of {{#crossLink "ProAct.Actor/into:method"}}{{/crossLink}} - sets <i>this actor</i> as a source
* to the passed <i>destination</i> actor.
*
* ```
* var sourceActor = <Actor implementation>;
* var actor = <Actor implementation>;
*
* sourceActor.out(actor);
* actor.on(function (v) {
* console.log(v);
* });
*
* Now if the any of the source actors is updated, the update will be printed on the console by the `actor`.
*
* ```
*
* @for ProAct.Actor
* @instance
* @method out
* @param {ProAct.Actor} destination
* The actor to set as source <i>this</i> to.
* @return {ProAct.Actor}
* <b>this</b>
*/
out: function (destination) {
destination.into(this);
return this;
},
/**
* Adds a new <i>transformation</i> to the list of transformations
* of <i>this actor</i>.
*
* <p>
* A transformation is a function or an object that has a <i>call</i> method defined.
* This function or call method should have one argument and to return a transformed version of it.
* If the returned value is {@link ProAct.Actor.BadValue}, the next transformations are skipped and the updating
* value/event becomes - bad value.
* </p>
*
* <p>
* Every value/event that updates <i>this actor</i> will be transformed using the new transformation.
* </p>
*
* @for ProAct.Actor
* @instance
* @method transform
* @protected
* @param {Object} transformation
* The transformation to add.
* @return {ProAct.Actor}
* <b>this</b>
*/
transform: function (transformation) {
this.transforms.push(transformation);
return this;
},
/**
* Adds a new <i>transformation</i> to the list of transformations
* of <i>this actor</i>.
*
* A transformation is a function or an object that has a <i>call</i> method defined.
* This function or call method should have one argument and to return a transformed version of it.
* If the returned value is {@link ProAct.Actor.BadValue}, the next transformations are skipped and the updating
* value/event becomes - bad value.
*
* Every value/event that updates <i>this actor</i> will be transformed using the new transformation.
*
* The idea of this method is that it just calls {{#crossLink "ProAct.Actor/transform:method"}}{{/crossLink}},
* but it can be overidden from another module.
*
* TODO Maybe transformStored is a bad name
*
* @for ProAct.Actor
* @instance
* @method transformStored
* @protected
* @param {Object} transformation
* The transformation to add. Can be string - to be retrieved by name.
* @param {String} type
* The type of the transformation, for example `mapping`.
* @return {ProAct.Actor}
* <b>this</b>
*/
transformStored: function (transformation, type) {
return this.transform(transformation);
},
/**
* Adds a mapping transformation to <i>this actor</i>.
* <p>
* Mapping transformations just transform one value into another. For example if we get update with
* the value of <i>3</i> and we have mapping transformation that returns the updating value powered by <i>2</i>,
* we'll get <i>9</i> as actual updating value.
* </p>
*
* @for ProAct.Actor
* @protected
* @instance
* @method mapping
* @param {Object} mappingFunction
* Function or object with a <i>call method</i> to use as map function.
* @return {ProAct.Actor}
* <b>this</b>
*/
mapping: function (mappingFunction) {
return this.transformStored(mappingFunction, 'map');
},
/**
* Adds a filtering transformation to <i>this actor</i>.
* <p>
* Filtering can be used to filter the incoming update values. For example you can
* filter by only odd numbers as update values.
* </p>
*
* @for ProAct.Actor
* @instance
* @protected
* @method filtering
* @param {Object} filteringFunction
* The filtering function or object with a call method, should return boolean.
* @return {ProAct.Actor}
* <b>this</b>
*/
filtering: function(filteringFunction) {
var self = this,
filter = filteringFunction.call ? function (val) {
if (filteringFunction.call(self, val)) {
return val;
};
return P.Actor.BadValue;
} : filteringFunction;
return this.transformStored(filter, 'filter');
},
/**
* Adds an accumulation transformation to <i>this actor</i>.
* <p>
* Accumulation is used to compute a value based on the previous one.
* </p>
*
* @for ProAct.Actor
* @instance
* @protected
* @method accumulation
* @param {Object} initVal
* Initial value for the accumulation. For example '0' for sum.
* @param {Object} accumulationFunction
* The function to accumulate.
* @return {ProAct.Actor}
* <b>this</b>
*/
accumulation: function (initVal, accumulationFunction) {
if (!accumulationFunction) {
accumulationFunction = initVal;
initVal = undefined;
}
var self = this,
val = initVal,
acc = accumulationFunction.call ? function (newVal) {
val = accumulationFunction.call(self, val, newVal)
return val;
} : accumulationFunction;
return this.transformStored(acc, 'acc');
},
/**
* Creates a new ProAct.Actor instance with source <i>this</i> and mapping
* the passed <i>mapping function</i>.
* <p>
* Should be overridden with creating the right actor.
* </p>
*
* ```
* var actor = sourceActor.map(function (el) {
* return el * el;
* });
* ```
*
* or
*
* ```
* var actor = sourceActor.map('+');
* ```
*
* @for ProAct.Actor
* @instance
* @abstract
* @method map
* @param {Object|Function|Strin} mappingFunction
* Function or object with a <i>call method</i> to use as map function.
* Can be string for predefined mapping functions.
* @return {ProAct.Actor}
* A new ProAct.Actor instance with the <i>mapping</i> applied.
*/
map: P.N,
/**
* Creates a new ProAct.Actor instance with source <i>this</i> and filtering
* the passed <i>filtering function</i>.
* <p>
* Should be overridden with creating the right actor.
* </p>
*
* ```
* var actor = sourceActor.filter(function (el) {
* return el % 2 == 0;
* });
* ```
*
* or
*
* ```
* var actor = sourceActor.filter('odd');
*
* ```
*
* @for ProAct.Actor
* @instance
* @abstract
* @method filter
* @param {Object} filteringFunction
* The filtering function or object with a call method, should return boolean.
* @return {ProAct.Actor}
* A new ProAct.Actor instance with the <i>filtering</i> applied.
*/
filter: P.N,
/**
* Creates a new ProAct.Actor instance with source <i>this</i> and accumulation
* the passed <i>accumulation function</i>.
* <p>
* Should be overridden with creating the right actor.
* </p>
*
* ```
* var actor = sourceActor.accumulate(0, function (current, el) {
* return current + el;
* });
* ```
*
* or
*
* ```
* var actor = sourceActor.accumulate('+');
* ```
*
* @for ProAct.Actor
* @instance
* @abstract
* @method accumulate
* @param {Object} initVal
* Initial value for the accumulation. For example '0' for sum.
* @param {Object} accumulationFunction
* The function to accumulate.
* @return {ProAct.Actor}
* A new ProAct.Actor instance with the <i>accumulation</i> applied.
*/
accumulate: P.N,
/**
* Defers a ProAct.Actor listener.
* <p>
* By default this means that the listener is put into active {{#crossLink "ProAct.Flow"}}{{/crossLink}} using it's
* {{#crossLink "ProAct.Flow/pushOnce:method"}}{{/crossLink}} method, but it can be overridden.
* </p>
*
* This method determines the order of actions, triggered by the changes in the data flow.
* The default implementation is executing only one update on this Actor per data flow change.
* This means that if the `Actor` depends on other three Actors, and all of them get updated,
* it is updated only once with the last update value.
*
* @for ProAct.Actor
* @protected
* @instance
* @method defer
* @param {Object} event
* The event/value to pass to the listener.
* @param {Object} listener
* The listener to defer. It should be a function or object defining the <i>call</i> method.
* @return {ProAct.Actor}
* <i>this</i>
*/
defer: function (event, listener) {
var queueName = (listener.queueName) ? listener.queueName : this.queueName;
if (P.U.isFunction(listener)) {
P.flow.pushOnce(queueName, listener, [event]);
} else {
P.flow.pushOnce(queueName, listener, listener.call, [event]);
}
return this;
}
};
proact.js