Base Class
A base class which objects requiring attributes and custom event support can extend. Base also handles the chaining of initializer and destructor methods across the hierarchy as part of object construction and destruction. Additionally, attributes configured through the static ATTRS property for each class in the hierarchy will be initialized by Base.
NOTE: Prior to version 3.11.0, ATTRS would get added a class at a time. That is,
Base would loop through each class in the hierarchy, and add the class' ATTRS, and
then call it's initializer, and move on to the subclass' ATTRS and initializer. As of
3.11.0, ATTRS from all classes in the hierarchy are added in one addAttrs call before
any initializers are called. This fixes subtle edge-case issues with subclass ATTRS overriding
superclass setter, getter or valueFn definitions and being unable to get/set attributes
defined by the subclass. This order of operation change may impact setter, getter or valueFn
code which expects a superclass' initializer to have run. This is expected to be rare, but to support
it, Base supports a _preAddAttrs(), method hook (same signature as addAttrs). Components can
implement this method on their prototype for edge cases which do require finer control over
the order in which attributes are added (see widget-htmlparser).
The static NAME property of each class extending from Base will be used as the identifier for the class, and is used by Base to prefix all events fired by instances of that class.
Constructor
Base
-
config
Parameters:
-
configObjectObject with configuration property name/value pairs. The object can be used to provide default values for the objects published attributes.
The config object can also contain the following non-attribute properties, providing a convenient way to configure events listeners and plugins for the instance, as part of the constructor call:
- on
- An event name to listener function map, to register event listeners for the "on" moment of the event. A constructor convenience property for the on method.
- after
- An event name to listener function map, to register event listeners for the "after" moment of the event. A constructor convenience property for the after method.
- bubbleTargets
- An object, or array of objects, to register as bubble targets for bubbled events fired by this instance. A constructor convenience property for the addTarget method.
- plugins
- A plugin, or array of plugins to be plugged into the instance (see PluginHost's plug method for signature details). A constructor convenience property for the plug method.
Item Index
Methods
- addAttr
- addAttrs
- addTarget
- after
- attrAdded
- before
- bubble
- build static deprecated
- create static
- destroy
- detach
- detachAll
- fire
- get
- getAttrs
- getEvent
- getTargets
- init
- mix static
- modifyAttr
- modifyAttrs static
- on
- once
- onceAfter
- parseType
- plug static
- publish
- removeAttr
- removeTarget
- reset
- set
- setAttrs
- subscribe deprecated
- toString
- unplug static
- unsubscribe deprecated
- unsubscribeAll deprecated
Attributes
Methods
addAttr
-
name -
config -
lazy
Adds an attribute with the provided configuration to the host object.
The config argument object supports the following properties:
- value <Any>
- The initial value to set on the attribute
- valueFn <Function | String>
-
A function, which will return the initial value to set on the attribute. This is useful for cases where the attribute configuration is defined statically, but needs to reference the host instance ("this") to obtain an initial value. If both the value and valueFn properties are defined, the value returned by the valueFn has precedence over the value property, unless it returns undefined, in which case the value property is used.
valueFn can also be set to a string, representing the name of the instance method to be used to retrieve the value.
- readOnly <boolean>
- Whether or not the attribute is read only. Attributes having readOnly set to true cannot be modified by invoking the set method.
- writeOnce <boolean> or <string>
-
Whether or not the attribute is "write once". Attributes having writeOnce set to true,
can only have their values set once, be it through the default configuration,
constructor configuration arguments, or by invoking set.
The writeOnce attribute can also be set to the string "initOnly", in which case the attribute can only be set during initialization (when used with Base, this means it can only be set during construction)
- setter <Function | String>
-
The setter function used to massage or normalize the value passed to the set method for the attribute. The value returned by the setter will be the final stored value. Returning Attribute.INVALID_VALUE, from the setter will prevent the value from being stored.
setter can also be set to a string, representing the name of the instance method to be used as the setter function.
- getter <Function | String>
-
The getter function used to massage or normalize the value returned by the get method for the attribute. The value returned by the getter function is the value which will be returned to the user when they invoke get.
getter can also be set to a string, representing the name of the instance method to be used as the getter function.
- validator <Function | String>
-
The validator function invoked prior to setting the stored value. Returning false from the validator function will prevent the value from being stored.
validator can also be set to a string, representing the name of the instance method to be used as the validator function.
- lazyAdd <boolean>
- Whether or not to delay initialization of the attribute until the first call to get/set it. This flag can be used to over-ride lazy initialization on a per attribute basis, when adding multiple attributes through the addAttrs method.
The setter, getter and validator are invoked with the value and name passed in as the first and second arguments, and with the context ("this") set to the host object.
Configuration properties outside of the list mentioned above are considered private properties used internally by attribute, and are not intended for public use.
Parameters:
-
nameStringThe name of the attribute.
-
configObjectAn object with attribute configuration property/value pairs, specifying the configuration for the attribute.
NOTE: The configuration object is modified when adding an attribute, so if you need to protect the original values, you will need to merge the object.
-
lazyBoolean(optional) Whether or not to add this attribute lazily (on the first call to get/set).
Returns:
A reference to the host object.
addAttrs
-
cfgs -
values -
lazy
Configures a group of attributes, and sets initial values.
NOTE: This method does not isolate the configuration object by merging/cloning. The caller is responsible for merging/cloning the configuration object if required.
Parameters:
-
cfgsObjectAn object with attribute name/configuration pairs.
-
valuesObjectAn object with attribute name/value pairs, defining the initial values to apply. Values defined in the cfgs argument will be over-written by values in this argument unless defined as read only.
-
lazyBooleanWhether or not to delay the intialization of these attributes until the first call to get/set. Individual attributes can over-ride this behavior by defining a lazyAdd configuration property in their configuration. See addAttr.
Returns:
A reference to the host object.
addTarget
-
o
Registers another EventTarget as a bubble target. Bubble order is determined by the order registered. Multiple targets can be specified.
Events can only bubble if emitFacade is true.
Included in the event-custom-complex submodule.
Parameters:
-
oEventTargetthe target to add
after
-
type -
fn -
[context] -
[arg*]
Subscribe to a custom event hosted by this object. The supplied callback will execute after any listeners add via the subscribe method, and after the default function, if configured for the event, has executed.
Parameters:
Returns:
A subscription handle capable of detaching the subscription
attrAdded
-
name
Checks if the given attribute has been added to the host
Parameters:
-
nameStringThe name of the attribute to check.
Returns:
true if an attribute with the given name has been added, false if it hasn't. This method will return true for lazily added attributes.
before
()
Executes the callback before a DOM event, custom event or method. If the first argument is a function, it is assumed the target is a method. For DOM and custom events, this is an alias for Y.on.
For DOM and custom events: type, callback, context, 0-n arguments
For methods: callback, object (method host), methodName, context, 0-n arguments
Returns:
detach handle
bubble
-
evt
Propagate an event. Requires the event-custom-complex module.
Parameters:
-
evtCustomEventthe custom event to propagate
Returns:
the aggregated return value from Event.Custom.fire
build
-
name -
main -
extensions -
cfg
Builds a custom constructor function (class) from the main function, and array of extension functions (classes) provided. The NAME field for the constructor function is defined by the first argument passed in.
The cfg object supports the following properties
- dynamic <boolean>
-
If true (default), a completely new class is created which extends the main class, and acts as the host on which the extension classes are augmented.
If false, the extensions classes are augmented directly to the main class, modifying the main class' prototype.
- aggregates <String[]>
- An array of static property names, which will get aggregated on to the built class, in addition to the default properties build will always aggregate as defined by the main class' static _buildCfg property.
Parameters:
-
nameFunctionThe name of the new class. Used to define the NAME property for the new class.
-
mainFunctionThe main class on which to base the built class
-
extensionsFunction[]The set of extension classes which will be augmented/aggregated to the built class.
-
cfgObjectOptional. Build configuration for the class (see description).
Returns:
A custom class, created from the provided main and extension classes
create
-
name -
main -
extensions -
px -
sx
Creates a new class (constructor function) which extends the base class passed in as the second argument, and mixes in the array of extensions provided.
Prototype properties or methods can be added to the new class, using the px argument (similar to Y.extend).
Static properties or methods can be added to the new class, using the sx argument (similar to Y.extend).
NOTE FOR COMPONENT DEVELOPERS: Both the base class, and extensions can define static a _buildCfg
property, which acts as class creation meta-data, and drives how special static properties from the base
class, or extensions should be copied, aggregated or (custom) mixed into the newly created class.
The _buildCfg property is a hash with 3 supported properties: statics, aggregates and custom, e.g:
// If the Base/Main class is the thing introducing the property:
MyBaseClass._buildCfg = {
// Static properties/methods to copy (Alias) to the built class.
statics: ["CopyThisMethod", "CopyThisProperty"],
// Static props to aggregate onto the built class.
aggregates: ["AggregateThisProperty"],
// Static properties which need custom handling (e.g. deep merge etc.)
custom: {
"CustomProperty" : function(property, Receiver, Supplier) {
...
var triggers = Receiver.CustomProperty.triggers;
Receiver.CustomProperty.triggers = triggers.concat(Supplier.CustomProperty.triggers);
...
}
}
};
MyBaseClass.CopyThisMethod = function() {...};
MyBaseClass.CopyThisProperty = "foo";
MyBaseClass.AggregateThisProperty = {...};
MyBaseClass.CustomProperty = {
triggers: [...]
}
// Or, if the Extension is the thing introducing the property:
MyExtension._buildCfg = {
statics : ...
aggregates : ...
custom : ...
}This way, when users pass your base or extension class to Y.Base.create or Y.Base.mix, they don't need to
know which properties need special handling. Y.Base has a buildCfg which defines ATTRS for custom mix handling
(to protect the static config objects), and Y.Widget has a buildCfg which specifies HTML_PARSER for
straight up aggregation.
Parameters:
-
nameStringThe name of the newly created class. Used to define the NAME property for the new class.
-
mainFunctionThe base class which the new class should extend. This class needs to be Base or a class derived from base (e.g. Widget).
-
extensionsFunction[]The list of extensions which will be mixed into the built class.
-
pxObjectThe set of prototype properties/methods to add to the built class.
-
sxObjectThe set of static properties/methods to add to the built class.
Returns:
The newly created class.
destroy
()
BaseCore
chainable
Destroy lifecycle method. Invokes destructors for the class hierarchy.
Returns:
A reference to this object
detach
-
type -
fn -
context
Detach one or more listeners the from the specified event
Parameters:
-
typeString | ObjectEither the handle to the subscriber or the type of event. If the type is not specified, it will attempt to remove the listener from all hosted events.
-
fnFunctionThe subscribed function to unsubscribe, if not supplied, all subscribers will be removed.
-
contextObjectThe custom object passed to subscribe. This is optional, but if supplied will be used to disambiguate multiple listeners that are the same (e.g., you subscribe many object using a function that lives on the prototype)
Returns:
the host
detachAll
-
type
Removes all listeners from the specified event. If the event type is not specified, all listeners from all hosted custom events will be removed.
Parameters:
-
typeStringThe type, or name of the event
fire
-
type -
arguments
Fire a custom event by name. The callback functions will be executed from the context specified when the event was created, and with the following parameters.
The first argument is the event type, and any additional arguments are passed to the listeners as parameters. If the first of these is an object literal, and the event is configured to emit an event facade, that object is mixed into the event facade and the facade is provided in place of the original object.
If the custom event object hasn't been created, then the event hasn't been published and it has no subscribers. For performance sake, we immediate exit in this case. This means the event won't bubble, so if the intention is that a bubble target be notified, the event must be published on this object first.
Parameters:
-
typeString | ObjectThe type of the event, or an object that contains a 'type' property.
-
argumentsObject*an arbitrary set of parameters to pass to the handler. If the first of these is an object literal and the event is configured to emit an event facade, the event facade will replace that parameter after the properties the object literal contains are copied to the event facade.
Returns:
True if the whole lifecycle of the event went through, false if at any point the event propagation was halted.
get
-
name
Returns the current value of the attribute. If the attribute has been configured with a 'getter' function, this method will delegate to the 'getter' to obtain the value of the attribute.
Parameters:
-
nameStringThe name of the attribute. If the value of the attribute is an Object, dot notation can be used to obtain the value of a property of the object (e.g.
get("x.y.z"))
Returns:
The value of the attribute
getAttrs
-
attrs
Gets multiple attribute values.
Parameters:
Returns:
An object with attribute name/value pairs.
getEvent
-
type -
prefixed
Returns the custom event of the provided type has been created, a falsy value otherwise
Parameters:
Returns:
the custom event or null
getTargets
()
Returns an array of bubble targets for this object.
Returns:
EventTarget[]
init
-
cfg
Init lifecycle method, invoked during construction. Sets up attributes and invokes initializers for the class hierarchy.
Parameters:
-
cfgObjectObject with configuration property name/value pairs
Returns:
A reference to this object
mix
-
main -
extensions
Mixes in a list of extensions to an existing class.
Parameters:
-
mainFunctionThe existing class into which the extensions should be mixed. The class needs to be Base or a class derived from Base (e.g. Widget)
-
extensionsFunction[]The set of extension classes which will mixed into the existing main class.
Returns:
The modified main class, with extensions mixed in.
modifyAttr
-
name -
config
Updates the configuration of an attribute which has already been added.
The properties which can be modified through this interface are limited to the following subset of attributes, which can be safely modified after a value has already been set on the attribute:
- readOnly;
- writeOnce;
- broadcast; and
- getter.
Note: New attributes cannot be added using this interface. New attributes must be added using addAttr, or an appropriate manner for a class which utilises Attributes (e.g. the ATTRS property in Base).
modifyAttrs
-
[ctor] -
configs
Provides a way to safely modify a Y.Base subclass' static ATTRS after
the class has been defined or created.
Base-based classes cache information about the class hierarchy in order to
efficiently create instances. This cache includes includes the aggregated
ATTRS configs. If the static ATTRS configs need to be modified after the
class has been defined or create, then use this method which will make sure
to clear any cached data before making any modifications.
on
-
type -
fn -
[context] -
[arg*]
Subscribe a callback function to a custom event fired by this object or from an object that bubbles its events to this object.
this.on("change", this._onChange, this);Callback functions for events published with emitFacade = true will
receive an EventFacade as the first argument (typically named "e").
These callbacks can then call e.preventDefault() to disable the
behavior published to that event's defaultFn. See the EventFacade
API for all available properties and methods. Subscribers to
non-emitFacade events will receive the arguments passed to fire()
after the event name.
To subscribe to multiple events at once, pass an object as the first argument, where the key:value pairs correspond to the eventName:callback.
this.on({
"attrChange" : this._onAttrChange,
"change" : this._onChange
});You can also pass an array of event names as the first argument to subscribe to all listed events with the same callback.
this.on([ "change", "attrChange" ], this._onChange);Returning false from a callback is supported as an alternative to
calling e.preventDefault(); e.stopPropagation();. However, it is
recommended to use the event methods whenever possible.
Parameters:
Returns:
A subscription handle capable of detaching that subscription
once
-
type -
fn -
[context] -
[arg*]
Listen to a custom event hosted by this object one time.
This is the equivalent to on except the
listener is immediatelly detached when it is executed.
Parameters:
Returns:
A subscription handle capable of detaching the subscription
onceAfter
-
type -
fn -
[context] -
[arg*]
Listen to a custom event hosted by this object one time.
This is the equivalent to after except the
listener is immediatelly detached when it is executed.
Parameters:
Returns:
A subscription handle capable of detaching that subscription
parseType
-
type -
[pre]
Takes the type parameter passed to 'on' and parses out the various pieces that could be included in the type. If the event type is passed without a prefix, it will be expanded to include the prefix one is supplied or the event target is configured with a default prefix.
Parameters:
Returns:
an array containing:
- the detach category, if supplied,
- the prefixed event type,
- whether or not this is an after listener,
- the supplied event type
plug
()
static
Alias for Plugin.Host.plug. See aliased method for argument and return value details.
publish
-
type -
opts
Creates a new custom event of the specified type. If a custom event by that name already exists, it will not be re-created. In either case the custom event is returned.
Parameters:
-
typeStringthe type, or name of the event
-
optsObjectoptional config params. Valid properties are:
-
[broadcast=false]Boolean optionalwhether or not the YUI instance and YUI global are notified when the event is fired.
-
[bubbles=true]Boolean optionalWhether or not this event bubbles. Events can only bubble if
emitFacadeis true. -
[context=this]Object optionalthe default execution context for the listeners.
-
[defaultFn]Function optionalthe default function to execute when this event fires if preventDefault was not called.
-
[emitFacade=false]Boolean optionalwhether or not this event emits a facade.
-
[prefix]String optionalthe prefix for this targets events, e.g., 'menu' in 'menu:click'.
-
[fireOnce=false]Boolean optionalif an event is configured to fire once, new subscribers after the fire will be notified immediately.
-
[async=false]Boolean optionalfireOnce event listeners will fire synchronously if the event has already fired unless
asyncistrue. -
[preventable=true]Boolean optionalwhether or not
preventDefault()has an effect. -
[preventedFn]Function optionala function that is executed when
preventDefault()is called. -
[queuable=false]Boolean optionalwhether or not this event can be queued during bubbling.
-
[silent]Boolean optionalif silent is true, debug messages are not provided for this event.
-
[stoppedFn]Function optionala function that is executed when stopPropagation is called.
-
[monitored]Boolean optionalspecifies whether or not this event should send notifications about when the event has been attached, detached, or published.
-
[type]String optionalthe event type (valid option if not provided as the first parameter to publish).
-
Returns:
the custom event
removeAttr
-
name
Removes an attribute from the host object
Parameters:
-
nameStringThe name of the attribute to be removed.
reset
-
name
Resets the attribute (or all attributes) to its initial value, as long as the attribute is not readOnly, or writeOnce.
Parameters:
-
nameStringOptional. The name of the attribute to reset. If omitted, all attributes are reset.
Returns:
A reference to the host object.
set
-
name -
value -
[opts]
Sets the value of an attribute.
Parameters:
-
nameStringThe name of the attribute. If the current value of the attribute is an Object, dot notation can be used to set the value of a property within the object (e.g.
set("x.y.z", 5)). -
valueAnyThe value to set the attribute to.
-
[opts]Object optionalOptional data providing the circumstances for the change.
Returns:
A reference to the host object.
setAttrs
-
attrs -
[opts]
Sets multiple attribute values.
Parameters:
Returns:
A reference to the host object.
subscribe
()
deprecated
subscribe to an event
toString
()
String
Default toString implementation. Provides the constructor NAME and the instance guid, if set.
Returns:
String representation for this object
unplug
()
static
Alias for Plugin.Host.unplug. See the aliased method for argument and return value details.
unsubscribe
()
deprecated
detach a listener
unsubscribeAll
-
type
Removes all listeners from the specified event. If the event type is not specified, all listeners from all hosted custom events will be removed.
Parameters:
-
typeStringThe type, or name of the event
Properties
ATTRS
Object
static
The default set of attributes which will be available for instances of this class, and their configuration. In addition to the configuration properties listed by Attribute's addAttr method, the attribute can also be configured with a "cloneDefaultValue" property, which defines how the statically defined value field should be protected ("shallow", "deep" and false are supported values).
By default if the value is an object literal or an array it will be "shallow" cloned, to protect the default value.
NAME
String
static
The string to be used to identify instances of this class, for example in prefixing events.
Classes extending Base, should define their own static NAME property, which should be camelCase by convention (e.g. MyClass.NAME = "myClass";).
Attributes
destroyed
Boolean
readonly
Flag indicating whether or not this object has been through the destroy lifecycle phase.
Default: false
Fires event destroyedChange
Fires when the value for the configuration attribute destroyed is
changed. You can listen for the event using the on method if you
wish to be notified before the attribute's value has changed, or
using the after method if you wish to be notified after the
attribute's value has changed.
Parameters:
-
eEventFacadeAn Event Facade object with the following attribute-specific properties added:
initialized
Boolean
readonly
Flag indicating whether or not this object has been through the init lifecycle phase.
Default: false
Fires event initializedChange
Fires when the value for the configuration attribute initialized is
changed. You can listen for the event using the on method if you
wish to be notified before the attribute's value has changed, or
using the after method if you wish to be notified after the
attribute's value has changed.
Parameters:
-
eEventFacadeAn Event Facade object with the following attribute-specific properties added:
Events
destroy
Lifecycle event for the destroy phase, fired prior to destruction. Invoking the preventDefault method on the event object provided to subscribers will prevent destruction from proceeding.
Subscribers to the "after" moment of this event, will be notified after destruction is complete (and as a result cannot prevent destruction).
Event Payload:
-
eEventFacadeEvent object
init
Lifecycle event for the init phase, fired prior to initialization. Invoking the preventDefault() method on the event object provided to subscribers will prevent initialization from occuring.
Subscribers to the "after" momemt of this event, will be notified after initialization of the object is complete (and therefore cannot prevent initialization).
Event Payload:
-
eEventFacadeEvent object, with a cfg property which refers to the configuration object passed to the constructor.