diff -r 000000000000 -r 40c8f766c9b8 src/cm/media/js/lib/yui/yui_3.0.0b1/build/attribute/attribute.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cm/media/js/lib/yui/yui_3.0.0b1/build/attribute/attribute.js Mon Nov 23 15:14:29 2009 +0100 @@ -0,0 +1,968 @@ +/* +Copyright (c) 2009, Yahoo! Inc. All rights reserved. +Code licensed under the BSD License: +http://developer.yahoo.net/yui/license.txt +version: 3.0.0b1 +build: 1163 +*/ +YUI.add('attribute', function(Y) { + + /** + * The State class maintains state for a collection of named items, with + * a varying number of properties defined. + * + * It avoids the need to create a separate class for the item, and separate instances + * of these classes for each item, by storing the state in a 2 level hash table, + * improving performance when the number of items is likely to be large. + * + * @constructor + * @class State + */ + Y.State = function() { + /** + * Hash of attributes + * @property data + */ + this.data = {}; + }; + + Y.State.prototype = { + + /** + * Adds a property to an item. + * + * @method add + * @param name {String} The name of the item. + * @param key {String} The name of the property. + * @param val {Any} The value of the property. + */ + add : function(name, key, val) { + var d = this.data; + d[key] = d[key] || {}; + d[key][name] = val; + }, + + /** + * Adds multiple properties to an item. + * + * @method addAll + * @param name {String} The name of the item. + * @param o {Object} A hash of property/value pairs. + */ + addAll: function(name, o) { + var key; + for (key in o) { + if (o.hasOwnProperty(key)) { + this.add(name, key, o[key]); + } + } + }, + + /** + * Removes a property from an item. + * + * @method remove + * @param name {String} The name of the item. + * @param key {String} The property to remove. + */ + remove: function(name, key) { + var d = this.data; + if (d[key] && (name in d[key])) { + delete d[key][name]; + } + }, + + /** + * Removes multiple properties from an item, or remove the item completely. + * + * @method removeAll + * @param name {String} The name of the item. + * @param o {Object|Array} Collection of properties to delete. If not provided, the entire item is removed. + */ + removeAll: function(name, o) { + var d = this.data; + + Y.each(o || d, function(v, k) { + if(Y.Lang.isString(k)) { + this.remove(name, k); + } else { + this.remove(name, v); + } + }, this); + }, + + /** + * For a given item, returns the value of the property requested, or undefined if not found. + * + * @method get + * @param name {String} The name of the item + * @param key {String} Optional. The property value to retrieve. + * @return {Any} The value of the supplied property. + */ + get: function(name, key) { + var d = this.data; + return (d[key] && name in d[key]) ? d[key][name] : undefined; + }, + + /** + * For the given item, returns a disposable object with all of the + * item's property/value pairs. + * + * @method getAll + * @param name {String} The name of the item + * @return {Object} An object with property/value pairs for the item. + */ + getAll : function(name) { + var d = this.data, o; + + Y.each(d, function(v, k) { + if (name in d[k]) { + o = o || {}; + o[k] = v[name]; + } + }, this); + + return o; + } + }; + + /** + * The attribute module provides an augmentable Attribute implementation, which + * adds configurable attributes and attribute change events to the class being + * augmented. It also provides a State class, which is used internally by Attribute, + * but can also be used independently to provide a name/property/value data structure to + * store state. + * + * @module attribute + */ + + var O = Y.Object, + EventTarget = Y.EventTarget, + + DOT = ".", + CHANGE = "Change", + + // Externally configurable props + GETTER = "getter", + SETTER = "setter", + READ_ONLY = "readOnly", + WRITE_ONCE = "writeOnce", + VALIDATOR = "validator", + VALUE = "value", + VALUE_FN = "valueFn", + BROADCAST = "broadcast", + LAZY_ADD = "lazyAdd", + + // Used for internal state management + ADDED = "added", + INITIALIZING = "initializing", + INIT_VALUE = "initValue", + PUBLISHED = "published", + DEF_VALUE = "defaultValue", + LAZY = "lazy", + IS_LAZY_ADD = "isLazyAdd", + + INVALID_VALUE, + MODIFIABLE = {}; + + // Properties which can be changed after the attribute has been added. + MODIFIABLE[READ_ONLY] = 1; + MODIFIABLE[WRITE_ONCE] = 1; + MODIFIABLE[GETTER] = 1; + MODIFIABLE[BROADCAST] = 1; + + /** + *

+ * Attribute provides configurable attribute support along with attribute change events. It is designed to be + * augmented onto a host class, and provides the host with the ability to configure attributes to store and retrieve state, + * along with attribute change events. + *

+ *

For example, attributes added to the host can be configured:

+ * + * + *

See the addAttr method, for the complete set of configuration + * options available for attributes

. + * + *

NOTE: Most implementations will be better off extending the Base class, + * instead of augmenting Attribute directly. Base augments Attribute and will handle the initial configuration + * of attributes for derived classes, accounting for values passed into the constructor.

+ * + * @class Attribute + * @uses EventTarget + */ + function Attribute() { + + // Perf tweak - avoid creating event literals if not required. + this._ATTR_E_FACADE = {}; + + EventTarget.call(this, {emitFacade:true}); + this._conf = new Y.State(); + } + + /** + *

The value to return from an attribute setter in order to prevent the set from going through.

+ * + *

You can return this value from your setter if you wish to combine validator and setter + * functionality into a single setter function, which either returns the massaged value to be stored or + * Attribute.INVALID_VALUE to prevent invalid values from being stored.

+ * + * @property Attribute.INVALID_VALUE + * @type Object + * @static + * @final + */ + Attribute.INVALID_VALUE = {}; + INVALID_VALUE = Attribute.INVALID_VALUE; + + /** + * The list of properties which can be configured for + * each attribute (e.g. setter, getter, writeOnce etc.). + * + * This property is used internally as a whitelist for faster + * Y.mix operations. + * + * @property Attribute._ATTR_CFG + * @type Array + * @static + * @protected + */ + Attribute._ATTR_CFG = [SETTER, GETTER, VALIDATOR, VALUE, VALUE_FN, WRITE_ONCE, READ_ONLY, LAZY_ADD, BROADCAST]; + + Attribute.prototype = { + /** + *

+ * 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>
+ *
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 defined, this precedence over the value property.
+ * + *
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>
+ *
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.
+ * + *
setter <Function>
+ *
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.
+ * + *
getter <Function>
+ *
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.
+ * + *
validator <Function>
+ *
The validator function invoked prior to setting the stored value. Returning + * false from the validator function will prevent the value from being stored.
+ * + *
broadcast <int>
+ *
If and how attribute change events for this attribute should be broadcast. See CustomEvent's broadcast property for + * valid values. By default attribute change events are not broadcast.
+ * + *
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.

+ * + * @method addAttr + * + * @param {String} name The name of the attribute. + * @param {Object} config An 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. + *

+ * + * @param {boolean} lazy (optional) Whether or not to add this attribute lazily (on the first call to get/set). + * + * @return {Object} A reference to the host object. + * + * @chainable + */ + addAttr: function(name, config, lazy) { + + var conf = this._conf; + + lazy = (LAZY_ADD in config) ? config[LAZY_ADD] : lazy; + + if (lazy && !this.attrAdded(name)) { + + conf.add(name, LAZY, config || {}); + conf.add(name, ADDED, true); + } else { + + + if (!this.attrAdded(name) || conf.get(name, IS_LAZY_ADD)) { + + config = config || {}; + + var value, hasValue = (VALUE in config); + + if(hasValue) { + // We'll go through set, don't want to set value in _conf directory + value = config.value; + delete config.value; + } + + config.added = true; + config.initializing = true; + + conf.addAll(name, config); + + if (hasValue) { + // Go through set, so that raw values get normalized/validated + this.set(name, value); + } + + conf.remove(name, INITIALIZING); + } + } + + return this; + }, + + /** + * Checks if the given attribute has been added to the host + * + * @method attrAdded + * @param {String} name The name of the attribute to check. + * @return {boolean} 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. + */ + attrAdded: function(name) { + return !!this._conf.get(name, ADDED); + }, + + /** + * 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. + *

+ * @method modifyAttr + * @param {String} name The name of the attribute whose configuration is to be updated. + * @param {Object} config An object with configuration property/value pairs, specifying the configuration properties to modify. + */ + modifyAttr: function(name, config) { + if (this.attrAdded(name)) { + + if (this._isLazyAttr(name)) { + this._addLazyAttr(name); + } + + var prop, conf = this._conf; + for (prop in config) { + if (MODIFIABLE[prop] && config.hasOwnProperty(prop)) { + conf.add(name, prop, config[prop]); + + // If we reconfigured broadcast, need to republish + if (prop === BROADCAST) { + conf.remove(name, PUBLISHED); + } + } + } + } + + }, + + /** + * Removes an attribute from the host object + * + * @method removeAttr + * @param {String} name The name of the attribute to be removed. + */ + removeAttr: function(name) { + this._conf.removeAll(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. + * + * @method get + * + * @param {String} name The 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")) + * + * @return {Any} The value of the attribute + */ + get : function(name) { + + var fullName = name, + conf = this._conf, + path, + getter, + val; + + if (name.indexOf(DOT) !== -1) { + path = name.split(DOT); + name = path.shift(); + } + + // On Demand - Should be rare - handles out of order valueFn references + if (this._tCfgs && this._tCfgs[name]) { + var cfg = {}; + cfg[name] = this._tCfgs[name]; + delete this._tCfgs[name]; + this._addAttrs(cfg, this._tVals); + } + + // Lazy Init + if (this._isLazyAttr(name)) { + this._addLazyAttr(name); + } + + val = conf.get(name, VALUE); + getter = conf.get(name, GETTER); + + val = (getter) ? getter.call(this, val, fullName) : val; + val = (path) ? O.getValue(val, path) : val; + + return val; + }, + + /** + * Checks whether or not the attribute is one which has been + * added lazily and still requires initialization. + * + * @method _isLazyAttr + * @private + * @param {String} name The name of the attribute + * @return {boolean} true if it's a lazily added attribute, false otherwise. + */ + _isLazyAttr: function(name) { + return this._conf.get(name, LAZY); + }, + + /** + * Finishes initializing an attribute which has been lazily added. + * + * @method _addLazyAttr + * @private + * @param {Object} name The name of the attribute + */ + _addLazyAttr: function(name) { + var conf = this._conf; + var lazyCfg = conf.get(name, LAZY); + conf.add(name, IS_LAZY_ADD, true); + conf.remove(name, LAZY); + this.addAttr(name, lazyCfg); + }, + + /** + * Sets the value of an attribute. + * + * @method set + * @chainable + * + * @param {String} name The 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)). + * + * @param {Any} value The value to set the attribute to. + * + * @param {Object} opts (Optional) Optional event data to be mixed into + * the event facade passed to subscribers of the attribute's change event. This + * can be used as a flexible way to identify the source of a call to set, allowing + * the developer to distinguish between set called internally by the host, vs. + * set called externally by the application developer. + * + * @return {Object} A reference to the host object. + */ + set : function(name, val, opts) { + return this._setAttr(name, val, opts); + }, + + /** + * Resets the attribute (or all attributes) to its initial value, as long as + * the attribute is not readOnly, or writeOnce. + * + * @method reset + * @param {String} name Optional. The name of the attribute to reset. If omitted, all attributes are reset. + * @return {Object} A reference to the host object. + * @chainable + */ + reset : function(name) { + if (name) { + if (this._isLazyAttr(name)) { + this._addLazyAttr(name); + } + this.set(name, this._conf.get(name, INIT_VALUE)); + } else { + var added = this._conf.data.added; + Y.each(added, function(v, n) { + this.reset(n); + }, this); + } + return this; + }, + + /** + * Allows setting of readOnly/writeOnce attributes. See set for argument details. + * + * @method _set + * @protected + * @chainable + * + * @param {String} name The name of the attribute. + * @param {Any} val The value to set the attribute to. + * @param {Object} opts (Optional) Optional event data to be mixed into + * the event facade passed to subscribers of the attribute's change event. + * @return {Object} A reference to the host object. + */ + _set : function(name, val, opts) { + return this._setAttr(name, val, opts, true); + }, + + /** + * Provides the common implementation for the public set and protected _set methods. + * + * See set for argument details. + * + * @method _setAttr + * @protected + * @chainable + * + * @param {String} name The name of the attribute. + * @param {Any} value The value to set the attribute to. + * @param {Object} opts (Optional) Optional event data to be mixed into + * the event facade passed to subscribers of the attribute's change event. + * @param {boolean} force If true, allows the caller to set values for + * readOnly or writeOnce attributes which have already been set. + * + * @return {Object} A reference to the host object. + */ + _setAttr : function(name, val, opts, force) { + var allowSet = true, + conf = this._conf, + data = conf.data, + initialSet, + strPath, + path, + currVal; + + if (name.indexOf(DOT) !== -1) { + strPath = name; + path = name.split(DOT); + name = path.shift(); + } + + if (this._isLazyAttr(name)) { + this._addLazyAttr(name); + } + + initialSet = (!data.value || !(name in data.value)); + + if (!this.attrAdded(name)) { + } else { + + if (!initialSet && !force) { + + if (conf.get(name, WRITE_ONCE)) { + allowSet = false; + } + + if (conf.get(name, READ_ONLY)) { + allowSet = false; + } + } + + if (allowSet) { + currVal = this.get(name); + + if (path) { + val = O.setValue(Y.clone(currVal), path, val); + + if (val === undefined) { + allowSet = false; + } + } + + if (allowSet) { + if (conf.get(name, INITIALIZING)) { + this._setAttrVal(name, strPath, currVal, val); + } else { + this._fireAttrChange(name, strPath, currVal, val, opts); + } + } + } + } + + return this; + }, + + /** + * Utility method to help setup the event payload and fire the attribute change event. + * + * @method _fireAttrChange + * @private + * @param {String} attrName The name of the attribute + * @param {String} subAttrName The full path of the property being changed, + * if this is a sub-attribute value being change. Otherwise null. + * @param {Any} currVal The current value of the attribute + * @param {Any} newVal The new value of the attribute + * @param {Object} opts Any additional event data to mix into the attribute change event's event facade. + */ + _fireAttrChange : function(attrName, subAttrName, currVal, newVal, opts) { + var eventName = attrName + CHANGE, + conf = this._conf, + facade; + + if (!conf.get(attrName, PUBLISHED)) { + this.publish(eventName, { + queuable:false, + defaultFn:this._defAttrChangeFn, + silent:true, + broadcast : conf.get(attrName, BROADCAST) + }); + conf.add(attrName, PUBLISHED, true); + } + + facade = (opts) ? Y.merge(opts) : this._ATTR_E_FACADE; + + facade.type = eventName; + facade.attrName = attrName; + facade.subAttrName = subAttrName; + facade.prevVal = currVal; + facade.newVal = newVal; + + this.fire(facade); + }, + + /** + * Default function for attribute change events. + * + * @private + * @method _defAttrChangeFn + * @param {EventFacade} e The event object for attribute change events. + */ + _defAttrChangeFn : function(e) { + if (!this._setAttrVal(e.attrName, e.subAttrName, e.prevVal, e.newVal)) { + // Prevent "after" listeners from being invoked since nothing changed. + e.stopImmediatePropagation(); + } else { + e.newVal = this._conf.get(e.attrName, VALUE); + } + }, + + /** + * Updates the stored value of the attribute in the privately held State object, + * if validation and setter passes. + * + * @method _setAttrVal + * @private + * @param {String} attrName The attribute name. + * @param {String} subAttrName The sub-attribute name, if setting a sub-attribute property ("x.y.z"). + * @param {Any} prevVal The currently stored value of the attribute. + * @param {Any} newVal The value which is going to be stored. + * + * @return {booolean} true if the new attribute value was stored, false if not. + */ + _setAttrVal : function(attrName, subAttrName, prevVal, newVal) { + + var allowSet = true, + conf = this._conf, + + validator = conf.get(attrName, VALIDATOR), + setter = conf.get(attrName, SETTER), + initializing = conf.get(attrName, INITIALIZING), + + name = subAttrName || attrName, + retVal; + + if (validator) { + var valid = validator.call(this, newVal, name); + + if (!valid && initializing) { + newVal = conf.get(attrName, DEF_VALUE); + valid = true; // Assume it's valid, for perf. + } + } + + if (!validator || valid) { + if (setter) { + retVal = setter.call(this, newVal, name); + + if (retVal === INVALID_VALUE) { + allowSet = false; + } else if (retVal !== undefined){ + newVal = retVal; + } + } + + if (allowSet) { + if(!subAttrName && newVal === prevVal) { + allowSet = false; + } else { + // Store value + if (conf.get(attrName, INIT_VALUE) === undefined) { + conf.add(attrName, INIT_VALUE, newVal); + } + conf.add(attrName, VALUE, newVal); + } + } + + } else { + allowSet = false; + } + + return allowSet; + }, + + /** + * Sets multiple attribute values. + * + * @method setAttrs + * @param {Object} attrs An object with attributes name/value pairs. + * @return {Object} A reference to the host object. + * @chainable + */ + setAttrs : function(attrs) { + for (var attr in attrs) { + if ( attrs.hasOwnProperty(attr) ) { + this.set(attr, attrs[attr]); + } + } + return this; + }, + + /** + * Gets multiple attribute values. + * + * @method getAttrs + * @param {Array | boolean} attrs Optional. An array of attribute names. If omitted, all attribute values are + * returned. If set to true, all attributes modified from their initial values are returned. + * @return {Object} An object with attribute name/value pairs. + */ + getAttrs : function(attrs) { + var o = {}, i, l, attr, val, + modifiedOnly = (attrs === true); + + attrs = (attrs && !modifiedOnly) ? attrs : O.keys(this._conf.data.added); + + for (i = 0, l = attrs.length; i < l; i++) { + // Go through get, to honor cloning/normalization + attr = attrs[i]; + val = this.get(attr); + + if (!modifiedOnly || this._conf.get(attr, VALUE) != this._conf.get(attr, INIT_VALUE)) { + o[attr] = this.get(attr); + } + } + + return o; + }, + + /** + * 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. + *

+ * + * @method addAttrs + * @chainable + * + * @param {Object} cfgs An object with attribute name/configuration pairs. + * @param {Object} values An 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. + * @param {boolean} lazy Whether 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. + * + * @return {Object} A reference to the host object. + */ + addAttrs : function(cfgs, values, lazy) { + if (cfgs) { + this._tCfgs = cfgs; + this._tVals = this._splitAttrVals(values); + + this._addAttrs(cfgs, this._tVals, lazy); + + this._tCfgs = this._tVals = null; + } + + return this; + }, + + /** + * Implementation behind the public addAttrs method. + * + * This method is invoked directly by get if it encounters a scenario + * in which an attribute's valueFn attempts to obtain the + * value an attribute in the same group of attributes, which has not yet + * been added (on demand initialization). + * + * @method _addAttrs + * @private + * @param {Object} cfgs An object with attribute name/configuration pairs. + * @param {Object} values An 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. + * @param {boolean} lazy Whether 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. + */ + _addAttrs : function(cfgs, values, lazy) { + var attr, + attrCfg, + value; + + for (attr in cfgs) { + if (cfgs.hasOwnProperty(attr)) { + + // Not Merging. Caller is responsible for isolating configs + attrCfg = cfgs[attr]; + attrCfg.defaultValue = attrCfg.value; + + // Handle simple, complex and user values, accounting for read-only + value = this._getAttrInitVal(attr, attrCfg, this._tVals); + + if (value !== undefined) { + attrCfg.value = value; + } + + if (this._tCfgs[attr]) { + delete this._tCfgs[attr]; + } + + this.addAttr(attr, attrCfg, lazy); + } + } + }, + + /** + * Utility method to split out simple attribute name/value pairs ("x") + * from complex attribute name/value pairs ("x.y.z"), so that complex + * attributes can be keyed by the top level attribute name. + * + * @method _splitAttrVals + * @param {Object} valueHash An object with attribute name/value pairs + * + * @return {Object} An object literal with 2 properties - "simple" and "complex", + * containing simple and complex attribute values respectively keyed + * by the top level attribute name, or null, if valueHash is falsey. + * + * @private + */ + _splitAttrVals : function(valueHash) { + var vals = {}, + subvals = {}, + path, + attr, + v, k; + + if (valueHash) { + for (k in valueHash) { + if (valueHash.hasOwnProperty(k)) { + if (k.indexOf(DOT) !== -1) { + path = k.split(DOT); + attr = path.shift(); + v = subvals[attr] = subvals[attr] || []; + v[v.length] = { + path : path, + value: valueHash[k] + }; + } else { + vals[k] = valueHash[k]; + } + } + } + return { simple:vals, complex:subvals }; + } else { + return null; + } + }, + + /** + * Returns the initial value of the given attribute from + * either the default configuration provided, or the + * over-ridden value if it exists in the set of initValues + * provided and the attribute is not read-only. + * + * @param {String} attr The name of the attribute + * @param {Object} cfg The attribute configuration object + * @param {Object} initValues The object with simple and complex attribute name/value pairs returned from _splitAttrVals + * + * @return {Any} The initial value of the attribute. + * + * @method _getAttrInitVal + * @private + */ + _getAttrInitVal : function(attr, cfg, initValues) { + + var val = (cfg.valueFn) ? cfg.valueFn.call(this) : cfg.value, + simple, + complex, + i, + l, + path, + subval, + subvals; + + if (!cfg.readOnly && initValues) { + + + // Simple Attributes + simple = initValues.simple; + if (simple && simple.hasOwnProperty(attr)) { + val = simple[attr]; + } + + // Complex Attributes (complex values applied, after simple, incase both are set) + complex = initValues.complex; + if (complex && complex.hasOwnProperty(attr)) { + subvals = complex[attr]; + for (i = 0, l = subvals.length; i < l; ++i) { + path = subvals[i].path; + subval = subvals[i].value; + O.setValue(val, path, subval); + } + } + } + + + return val; + } + }; + + // Basic prototype augment - no lazy constructor invocation. + Y.mix(Attribute, EventTarget, false, null, 1); + + Y.Attribute = Attribute; + + + +}, '3.0.0b1' ,{requires:['event-custom']});