--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui3-3.15.0/build/node-base/node-base-debug.js Mon Mar 10 15:19:48 2014 +0100
@@ -0,0 +1,998 @@
+YUI.add('node-base', function (Y, NAME) {
+
+/**
+ * @module node
+ * @submodule node-base
+ */
+
+var methods = [
+/**
+ * Determines whether each node has the given className.
+ * @method hasClass
+ * @for Node
+ * @param {String} className the class name to search for
+ * @return {Boolean} Whether or not the element has the specified class
+ */
+ 'hasClass',
+
+/**
+ * Adds a class name to each node.
+ * @method addClass
+ * @param {String} className the class name to add to the node's class attribute
+ * @chainable
+ */
+ 'addClass',
+
+/**
+ * Removes a class name from each node.
+ * @method removeClass
+ * @param {String} className the class name to remove from the node's class attribute
+ * @chainable
+ */
+ 'removeClass',
+
+/**
+ * Replace a class with another class for each node.
+ * If no oldClassName is present, the newClassName is simply added.
+ * @method replaceClass
+ * @param {String} oldClassName the class name to be replaced
+ * @param {String} newClassName the class name that will be replacing the old class name
+ * @chainable
+ */
+ 'replaceClass',
+
+/**
+ * If the className exists on the node it is removed, if it doesn't exist it is added.
+ * @method toggleClass
+ * @param {String} className the class name to be toggled
+ * @param {Boolean} force Option to force adding or removing the class.
+ * @chainable
+ */
+ 'toggleClass'
+];
+
+Y.Node.importMethod(Y.DOM, methods);
+/**
+ * Determines whether each node has the given className.
+ * @method hasClass
+ * @see Node.hasClass
+ * @for NodeList
+ * @param {String} className the class name to search for
+ * @return {Array} An array of booleans for each node bound to the NodeList.
+ */
+
+/**
+ * Adds a class name to each node.
+ * @method addClass
+ * @see Node.addClass
+ * @param {String} className the class name to add to the node's class attribute
+ * @chainable
+ */
+
+/**
+ * Removes a class name from each node.
+ * @method removeClass
+ * @see Node.removeClass
+ * @param {String} className the class name to remove from the node's class attribute
+ * @chainable
+ */
+
+/**
+ * Replace a class with another class for each node.
+ * If no oldClassName is present, the newClassName is simply added.
+ * @method replaceClass
+ * @see Node.replaceClass
+ * @param {String} oldClassName the class name to be replaced
+ * @param {String} newClassName the class name that will be replacing the old class name
+ * @chainable
+ */
+
+/**
+ * If the className exists on the node it is removed, if it doesn't exist it is added.
+ * @method toggleClass
+ * @see Node.toggleClass
+ * @param {String} className the class name to be toggled
+ * @chainable
+ */
+Y.NodeList.importMethod(Y.Node.prototype, methods);
+/**
+ * @module node
+ * @submodule node-base
+ */
+
+var Y_Node = Y.Node,
+ Y_DOM = Y.DOM;
+
+/**
+ * Returns a new dom node using the provided markup string.
+ * @method create
+ * @static
+ * @param {String} html The markup used to create the element.
+ * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
+ * to escape html content.
+ * @param {HTMLDocument} doc An optional document context
+ * @return {Node} A Node instance bound to a DOM node or fragment
+ * @for Node
+ */
+Y_Node.create = function(html, doc) {
+ if (doc && doc._node) {
+ doc = doc._node;
+ }
+ return Y.one(Y_DOM.create(html, doc));
+};
+
+Y.mix(Y_Node.prototype, {
+ /**
+ * Creates a new Node using the provided markup string.
+ * @method create
+ * @param {String} html The markup used to create the element.
+ * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
+ * to escape html content.
+ * @param {HTMLDocument} doc An optional document context
+ * @return {Node} A Node instance bound to a DOM node or fragment
+ */
+ create: Y_Node.create,
+
+ /**
+ * Inserts the content before the reference node.
+ * @method insert
+ * @param {String | Node | HTMLElement | NodeList | HTMLCollection} content The content to insert.
+ * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
+ * to escape html content.
+ * @param {Int | Node | HTMLElement | String} where The position to insert at.
+ * Possible "where" arguments
+ * <dl>
+ * <dt>Y.Node</dt>
+ * <dd>The Node to insert before</dd>
+ * <dt>HTMLElement</dt>
+ * <dd>The element to insert before</dd>
+ * <dt>Int</dt>
+ * <dd>The index of the child element to insert before</dd>
+ * <dt>"replace"</dt>
+ * <dd>Replaces the existing HTML</dd>
+ * <dt>"before"</dt>
+ * <dd>Inserts before the existing HTML</dd>
+ * <dt>"before"</dt>
+ * <dd>Inserts content before the node</dd>
+ * <dt>"after"</dt>
+ * <dd>Inserts content after the node</dd>
+ * </dl>
+ * @chainable
+ */
+ insert: function(content, where) {
+ this._insert(content, where);
+ return this;
+ },
+
+ _insert: function(content, where) {
+ var node = this._node,
+ ret = null;
+
+ if (typeof where == 'number') { // allow index
+ where = this._node.childNodes[where];
+ } else if (where && where._node) { // Node
+ where = where._node;
+ }
+
+ if (content && typeof content != 'string') { // allow Node or NodeList/Array instances
+ content = content._node || content._nodes || content;
+ }
+ ret = Y_DOM.addHTML(node, content, where);
+
+ return ret;
+ },
+
+ /**
+ * Inserts the content as the firstChild of the node.
+ * @method prepend
+ * @param {String | Node | HTMLElement} content The content to insert.
+ * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
+ * to escape html content.
+ * @chainable
+ */
+ prepend: function(content) {
+ return this.insert(content, 0);
+ },
+
+ /**
+ * Inserts the content as the lastChild of the node.
+ * @method append
+ * @param {String | Node | HTMLElement} content The content to insert.
+ * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
+ * to escape html content.
+ * @chainable
+ */
+ append: function(content) {
+ return this.insert(content, null);
+ },
+
+ /**
+ * @method appendChild
+ * @param {String | HTMLElement | Node} node Node to be appended.
+ * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
+ * to escape html content.
+ * @return {Node} The appended node
+ */
+ appendChild: function(node) {
+ return Y_Node.scrubVal(this._insert(node));
+ },
+
+ /**
+ * @method insertBefore
+ * @param {String | HTMLElement | Node} newNode Node to be appended
+ * @param {HTMLElement | Node} refNode Node to be inserted before.
+ * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
+ * to escape html content.
+ * @return {Node} The inserted node
+ */
+ insertBefore: function(newNode, refNode) {
+ return Y.Node.scrubVal(this._insert(newNode, refNode));
+ },
+
+ /**
+ * Appends the node to the given node.
+ * @method appendTo
+ * @param {Node | HTMLElement} node The node to append to
+ * @chainable
+ */
+ appendTo: function(node) {
+ Y.one(node).append(this);
+ return this;
+ },
+
+ // This method is deprecated, and is intentionally left undocumented.
+ // Use `setHTML` instead.
+ setContent: function(content) {
+ this._insert(content, 'replace');
+ return this;
+ },
+
+ // This method is deprecated, and is intentionally left undocumented.
+ // Use `getHTML` instead.
+ getContent: function() {
+ var node = this;
+
+ if (node._node.nodeType === 11) { // 11 === Node.DOCUMENT_FRAGMENT_NODE
+ // "this", when it is a document fragment, must be cloned because
+ // the nodes contained in the fragment actually disappear once
+ // the fragment is appended anywhere
+ node = node.create("<div/>").append(node.cloneNode(true));
+ }
+
+ return node.get("innerHTML");
+ }
+});
+
+/**
+ * Replaces the node's current html content with the content provided.
+ * Note that this passes to innerHTML and is not escaped.
+ * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
+ * to escape html content or `set('text')` to add as text.
+ * @method setHTML
+ * @param {String | Node | HTMLElement | NodeList | HTMLCollection} content The content to insert
+ * @chainable
+ */
+Y.Node.prototype.setHTML = Y.Node.prototype.setContent;
+
+/**
+ * Returns the node's current html content (e.g. innerHTML)
+ * @method getHTML
+ * @return {String} The html content
+ */
+Y.Node.prototype.getHTML = Y.Node.prototype.getContent;
+
+Y.NodeList.importMethod(Y.Node.prototype, [
+ /**
+ * Called on each Node instance
+ * @for NodeList
+ * @method append
+ * @see Node.append
+ */
+ 'append',
+
+ /**
+ * Called on each Node instance
+ * @for NodeList
+ * @method insert
+ * @see Node.insert
+ */
+ 'insert',
+
+ /**
+ * Called on each Node instance
+ * @for NodeList
+ * @method appendChild
+ * @see Node.appendChild
+ */
+ 'appendChild',
+
+ /**
+ * Called on each Node instance
+ * @for NodeList
+ * @method insertBefore
+ * @see Node.insertBefore
+ */
+ 'insertBefore',
+
+ /**
+ * Called on each Node instance
+ * @for NodeList
+ * @method prepend
+ * @see Node.prepend
+ */
+ 'prepend',
+
+ 'setContent',
+
+ 'getContent',
+
+ /**
+ * Called on each Node instance
+ * Note that this passes to innerHTML and is not escaped.
+ * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
+ * to escape html content or `set('text')` to add as text.
+ * @for NodeList
+ * @method setHTML
+ * @see Node.setHTML
+ */
+ 'setHTML',
+
+ /**
+ * Called on each Node instance
+ * @for NodeList
+ * @method getHTML
+ * @see Node.getHTML
+ */
+ 'getHTML'
+]);
+/**
+ * @module node
+ * @submodule node-base
+ */
+
+var Y_Node = Y.Node,
+ Y_DOM = Y.DOM;
+
+/**
+ * Static collection of configuration attributes for special handling
+ * @property ATTRS
+ * @static
+ * @type object
+ */
+Y_Node.ATTRS = {
+ /**
+ * Allows for getting and setting the text of an element.
+ * Formatting is preserved and special characters are treated literally.
+ * @config text
+ * @type String
+ */
+ text: {
+ getter: function() {
+ return Y_DOM.getText(this._node);
+ },
+
+ setter: function(content) {
+ Y_DOM.setText(this._node, content);
+ return content;
+ }
+ },
+
+ /**
+ * Allows for getting and setting the text of an element.
+ * Formatting is preserved and special characters are treated literally.
+ * @config for
+ * @type String
+ */
+ 'for': {
+ getter: function() {
+ return Y_DOM.getAttribute(this._node, 'for');
+ },
+
+ setter: function(val) {
+ Y_DOM.setAttribute(this._node, 'for', val);
+ return val;
+ }
+ },
+
+ 'options': {
+ getter: function() {
+ return this._node.getElementsByTagName('option');
+ }
+ },
+
+ /**
+ * Returns a NodeList instance of all HTMLElement children.
+ * @readOnly
+ * @config children
+ * @type NodeList
+ */
+ 'children': {
+ getter: function() {
+ var node = this._node,
+ children = node.children,
+ childNodes, i, len;
+
+ if (!children) {
+ childNodes = node.childNodes;
+ children = [];
+
+ for (i = 0, len = childNodes.length; i < len; ++i) {
+ if (childNodes[i].tagName) {
+ children[children.length] = childNodes[i];
+ }
+ }
+ }
+ return Y.all(children);
+ }
+ },
+
+ value: {
+ getter: function() {
+ return Y_DOM.getValue(this._node);
+ },
+
+ setter: function(val) {
+ Y_DOM.setValue(this._node, val);
+ return val;
+ }
+ }
+};
+
+Y.Node.importMethod(Y.DOM, [
+ /**
+ * Allows setting attributes on DOM nodes, normalizing in some cases.
+ * This passes through to the DOM node, allowing for custom attributes.
+ * @method setAttribute
+ * @for Node
+ * @for NodeList
+ * @chainable
+ * @param {string} name The attribute name
+ * @param {string} value The value to set
+ */
+ 'setAttribute',
+ /**
+ * Allows getting attributes on DOM nodes, normalizing in some cases.
+ * This passes through to the DOM node, allowing for custom attributes.
+ * @method getAttribute
+ * @for Node
+ * @for NodeList
+ * @param {string} name The attribute name
+ * @return {string} The attribute value
+ */
+ 'getAttribute'
+
+]);
+/**
+ * @module node
+ * @submodule node-base
+ */
+
+var Y_Node = Y.Node;
+var Y_NodeList = Y.NodeList;
+/**
+ * List of events that route to DOM events
+ * @static
+ * @property DOM_EVENTS
+ * @for Node
+ */
+
+Y_Node.DOM_EVENTS = {
+ abort: 1,
+ beforeunload: 1,
+ blur: 1,
+ change: 1,
+ click: 1,
+ close: 1,
+ command: 1,
+ contextmenu: 1,
+ copy: 1,
+ cut: 1,
+ dblclick: 1,
+ DOMMouseScroll: 1,
+ drag: 1,
+ dragstart: 1,
+ dragenter: 1,
+ dragover: 1,
+ dragleave: 1,
+ dragend: 1,
+ drop: 1,
+ error: 1,
+ focus: 1,
+ key: 1,
+ keydown: 1,
+ keypress: 1,
+ keyup: 1,
+ load: 1,
+ message: 1,
+ mousedown: 1,
+ mouseenter: 1,
+ mouseleave: 1,
+ mousemove: 1,
+ mousemultiwheel: 1,
+ mouseout: 1,
+ mouseover: 1,
+ mouseup: 1,
+ mousewheel: 1,
+ orientationchange: 1,
+ paste: 1,
+ reset: 1,
+ resize: 1,
+ select: 1,
+ selectstart: 1,
+ submit: 1,
+ scroll: 1,
+ textInput: 1,
+ unload: 1
+};
+
+// Add custom event adaptors to this list. This will make it so
+// that delegate, key, available, contentready, etc all will
+// be available through Node.on
+Y.mix(Y_Node.DOM_EVENTS, Y.Env.evt.plugins);
+
+Y.augment(Y_Node, Y.EventTarget);
+
+Y.mix(Y_Node.prototype, {
+ /**
+ * Removes event listeners from the node and (optionally) its subtree
+ * @method purge
+ * @param {Boolean} recurse (optional) Whether or not to remove listeners from the
+ * node's subtree
+ * @param {String} type (optional) Only remove listeners of the specified type
+ * @chainable
+ *
+ */
+ purge: function(recurse, type) {
+ Y.Event.purgeElement(this._node, recurse, type);
+ return this;
+ }
+
+});
+
+Y.mix(Y.NodeList.prototype, {
+ _prepEvtArgs: function(type, fn, context) {
+ // map to Y.on/after signature (type, fn, nodes, context, arg1, arg2, etc)
+ var args = Y.Array(arguments, 0, true);
+
+ if (args.length < 2) { // type only (event hash) just add nodes
+ args[2] = this._nodes;
+ } else {
+ args.splice(2, 0, this._nodes);
+ }
+
+ args[3] = context || this; // default to NodeList instance as context
+
+ return args;
+ },
+
+ /**
+ Subscribe a callback function for each `Node` in the collection to execute
+ in response to a DOM event.
+
+ NOTE: Generally, the `on()` method should be avoided on `NodeLists`, in
+ favor of using event delegation from a parent Node. See the Event user
+ guide for details.
+
+ Most DOM events are associated with a preventable default behavior, such as
+ link clicks navigating to a new page. Callbacks are passed a
+ `DOMEventFacade` object as their first argument (usually called `e`) that
+ can be used to prevent this default behavior with `e.preventDefault()`. See
+ the `DOMEventFacade` API for all available properties and methods on the
+ object.
+
+ By default, the `this` object will be the `NodeList` that the subscription
+ came from, <em>not the `Node` that received the event</em>. Use
+ `e.currentTarget` to refer to the `Node`.
+
+ 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.
+
+ @example
+
+ Y.all(".sku").on("keydown", function (e) {
+ if (e.keyCode === 13) {
+ e.preventDefault();
+
+ // Use e.currentTarget to refer to the individual Node
+ var item = Y.MyApp.searchInventory( e.currentTarget.get('value') );
+ // etc ...
+ }
+ });
+
+ @method on
+ @param {String} type The name of the event
+ @param {Function} fn The callback to execute in response to the event
+ @param {Object} [context] Override `this` object in callback
+ @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
+ @return {EventHandle} A subscription handle capable of detaching that
+ subscription
+ @for NodeList
+ **/
+ on: function(type, fn, context) {
+ return Y.on.apply(Y, this._prepEvtArgs.apply(this, arguments));
+ },
+
+ /**
+ * Applies an one-time event listener to each Node bound to the NodeList.
+ * @method once
+ * @param {String} type The event being listened for
+ * @param {Function} fn The handler to call when the event fires
+ * @param {Object} context The context to call the handler with.
+ * Default is the NodeList instance.
+ * @return {EventHandle} A subscription handle capable of detaching that
+ * subscription
+ * @for NodeList
+ */
+ once: function(type, fn, context) {
+ return Y.once.apply(Y, this._prepEvtArgs.apply(this, arguments));
+ },
+
+ /**
+ * Applies an event listener to each Node bound to the NodeList.
+ * The handler is called only after all on() handlers are called
+ * and the event is not prevented.
+ * @method after
+ * @param {String} type The event being listened for
+ * @param {Function} fn The handler to call when the event fires
+ * @param {Object} context The context to call the handler with.
+ * Default is the NodeList instance.
+ * @return {EventHandle} A subscription handle capable of detaching that
+ * subscription
+ * @for NodeList
+ */
+ after: function(type, fn, context) {
+ return Y.after.apply(Y, this._prepEvtArgs.apply(this, arguments));
+ },
+
+ /**
+ * Applies an one-time event listener to each Node bound to the NodeList
+ * that will be called only after all on() handlers are called and the
+ * event is not prevented.
+ *
+ * @method onceAfter
+ * @param {String} type The event being listened for
+ * @param {Function} fn The handler to call when the event fires
+ * @param {Object} context The context to call the handler with.
+ * Default is the NodeList instance.
+ * @return {EventHandle} A subscription handle capable of detaching that
+ * subscription
+ * @for NodeList
+ */
+ onceAfter: function(type, fn, context) {
+ return Y.onceAfter.apply(Y, this._prepEvtArgs.apply(this, arguments));
+ }
+});
+
+Y_NodeList.importMethod(Y.Node.prototype, [
+ /**
+ * Called on each Node instance
+ * @method detach
+ * @see Node.detach
+ * @for NodeList
+ */
+ 'detach',
+
+ /** Called on each Node instance
+ * @method detachAll
+ * @see Node.detachAll
+ * @for NodeList
+ */
+ 'detachAll'
+]);
+
+/**
+Subscribe a callback function to execute in response to a DOM event or custom
+event.
+
+Most DOM events are associated with a preventable default behavior such as
+link clicks navigating to a new page. Callbacks are passed a `DOMEventFacade`
+object as their first argument (usually called `e`) that can be used to
+prevent this default behavior with `e.preventDefault()`. See the
+`DOMEventFacade` API for all available properties and methods on the object.
+
+If the event name passed as the first parameter is not a whitelisted DOM event,
+it will be treated as a custom event subscriptions, allowing
+`node.fire('customEventName')` later in the code. Refer to the Event user guide
+for the full DOM event whitelist.
+
+By default, the `this` object in the callback will refer to the subscribed
+`Node`.
+
+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.
+
+@example
+
+ Y.one("#my-form").on("submit", function (e) {
+ e.preventDefault();
+
+ // proceed with ajax form submission instead...
+ });
+
+@method on
+@param {String} type The name of the event
+@param {Function} fn The callback to execute in response to the event
+@param {Object} [context] Override `this` object in callback
+@param {Any} [arg*] 0..n additional arguments to supply to the subscriber
+@return {EventHandle} A subscription handle capable of detaching that
+ subscription
+@for Node
+**/
+
+Y.mix(Y.Node.ATTRS, {
+ offsetHeight: {
+ setter: function(h) {
+ Y.DOM.setHeight(this._node, h);
+ return h;
+ },
+
+ getter: function() {
+ return this._node.offsetHeight;
+ }
+ },
+
+ offsetWidth: {
+ setter: function(w) {
+ Y.DOM.setWidth(this._node, w);
+ return w;
+ },
+
+ getter: function() {
+ return this._node.offsetWidth;
+ }
+ }
+});
+
+Y.mix(Y.Node.prototype, {
+ sizeTo: function(w, h) {
+ var node;
+ if (arguments.length < 2) {
+ node = Y.one(w);
+ w = node.get('offsetWidth');
+ h = node.get('offsetHeight');
+ }
+
+ this.setAttrs({
+ offsetWidth: w,
+ offsetHeight: h
+ });
+ }
+});
+
+if (!Y.config.doc.documentElement.hasAttribute) { // IE < 8
+ Y.Node.prototype.hasAttribute = function(attr) {
+ if (attr === 'value') {
+ if (this.get('value') !== "") { // IE < 8 fails to populate specified when set in HTML
+ return true;
+ }
+ }
+ return !!(this._node.attributes[attr] &&
+ this._node.attributes[attr].specified);
+ };
+}
+
+// IE throws an error when calling focus() on an element that's invisible, not
+// displayed, or disabled.
+Y.Node.prototype.focus = function () {
+ try {
+ this._node.focus();
+ } catch (e) {
+ Y.log('error focusing node: ' + e.toString(), 'error', 'node');
+ }
+
+ return this;
+};
+
+// IE throws error when setting input.type = 'hidden',
+// input.setAttribute('type', 'hidden') and input.attributes.type.value = 'hidden'
+Y.Node.ATTRS.type = {
+ setter: function(val) {
+ if (val === 'hidden') {
+ try {
+ this._node.type = 'hidden';
+ } catch(e) {
+ this._node.style.display = 'none';
+ this._inputType = 'hidden';
+ }
+ } else {
+ try { // IE errors when changing the type from "hidden'
+ this._node.type = val;
+ } catch (e) {
+ Y.log('error setting type: ' + val, 'info', 'node');
+ }
+ }
+ return val;
+ },
+
+ getter: function() {
+ return this._inputType || this._node.type;
+ },
+
+ _bypassProxy: true // don't update DOM when using with Attribute
+};
+
+if (Y.config.doc.createElement('form').elements.nodeType) {
+ // IE: elements collection is also FORM node which trips up scrubVal.
+ Y.Node.ATTRS.elements = {
+ getter: function() {
+ return this.all('input, textarea, button, select');
+ }
+ };
+}
+/**
+ * Provides methods for managing custom Node data.
+ *
+ * @module node
+ * @main node
+ * @submodule node-data
+ */
+
+Y.mix(Y.Node.prototype, {
+ _initData: function() {
+ if (! ('_data' in this)) {
+ this._data = {};
+ }
+ },
+
+ /**
+ * @method getData
+ * @for Node
+ * @description Retrieves arbitrary data stored on a Node instance.
+ * If no data is associated with the Node, it will attempt to retrieve
+ * a value from the corresponding HTML data attribute. (e.g. node.getData('foo')
+ * will check node.getAttribute('data-foo')).
+ * @param {string} name Optional name of the data field to retrieve.
+ * If no name is given, all data is returned.
+ * @return {any | Object} Whatever is stored at the given field,
+ * or an object hash of all fields.
+ */
+ getData: function(name) {
+ this._initData();
+ var data = this._data,
+ ret = data;
+
+ if (arguments.length) { // single field
+ if (name in data) {
+ ret = data[name];
+ } else { // initialize from HTML attribute
+ ret = this._getDataAttribute(name);
+ }
+ } else if (typeof data == 'object' && data !== null) { // all fields
+ ret = {};
+ Y.Object.each(data, function(v, n) {
+ ret[n] = v;
+ });
+
+ ret = this._getDataAttributes(ret);
+ }
+
+ return ret;
+
+ },
+
+ _getDataAttributes: function(ret) {
+ ret = ret || {};
+ var i = 0,
+ attrs = this._node.attributes,
+ len = attrs.length,
+ prefix = this.DATA_PREFIX,
+ prefixLength = prefix.length,
+ name;
+
+ while (i < len) {
+ name = attrs[i].name;
+ if (name.indexOf(prefix) === 0) {
+ name = name.substr(prefixLength);
+ if (!(name in ret)) { // only merge if not already stored
+ ret[name] = this._getDataAttribute(name);
+ }
+ }
+
+ i += 1;
+ }
+
+ return ret;
+ },
+
+ _getDataAttribute: function(name) {
+ name = this.DATA_PREFIX + name;
+
+ var node = this._node,
+ attrs = node.attributes,
+ data = attrs && attrs[name] && attrs[name].value;
+
+ return data;
+ },
+
+ /**
+ * @method setData
+ * @for Node
+ * @description Stores arbitrary data on a Node instance.
+ * This is not stored with the DOM node.
+ * @param {string} name The name of the field to set. If no val
+ * is given, name is treated as the data and overrides any existing data.
+ * @param {any} val The value to be assigned to the field.
+ * @chainable
+ */
+ setData: function(name, val) {
+ this._initData();
+ if (arguments.length > 1) {
+ this._data[name] = val;
+ } else {
+ this._data = name;
+ }
+
+ return this;
+ },
+
+ /**
+ * @method clearData
+ * @for Node
+ * @description Clears internally stored data.
+ * @param {string} name The name of the field to clear. If no name
+ * is given, all data is cleared.
+ * @chainable
+ */
+ clearData: function(name) {
+ if ('_data' in this) {
+ if (typeof name != 'undefined') {
+ delete this._data[name];
+ } else {
+ delete this._data;
+ }
+ }
+
+ return this;
+ }
+});
+
+Y.mix(Y.NodeList.prototype, {
+ /**
+ * @method getData
+ * @for NodeList
+ * @description Retrieves arbitrary data stored on each Node instance
+ * bound to the NodeList.
+ * @see Node
+ * @param {string} name Optional name of the data field to retrieve.
+ * If no name is given, all data is returned.
+ * @return {Array} An array containing all of the data for each Node instance.
+ * or an object hash of all fields.
+ */
+ getData: function(name) {
+ var args = (arguments.length) ? [name] : [];
+ return this._invoke('getData', args, true);
+ },
+
+ /**
+ * @method setData
+ * @for NodeList
+ * @description Stores arbitrary data on each Node instance bound to the
+ * NodeList. This is not stored with the DOM node.
+ * @param {string} name The name of the field to set. If no name
+ * is given, name is treated as the data and overrides any existing data.
+ * @param {any} val The value to be assigned to the field.
+ * @chainable
+ */
+ setData: function(name, val) {
+ var args = (arguments.length > 1) ? [name, val] : [name];
+ return this._invoke('setData', args);
+ },
+
+ /**
+ * @method clearData
+ * @for NodeList
+ * @description Clears data on all Node instances bound to the NodeList.
+ * @param {string} name The name of the field to clear. If no name
+ * is given, all data is cleared.
+ * @chainable
+ */
+ clearData: function(name) {
+ var args = (arguments.length) ? [name] : [];
+ return this._invoke('clearData', [name]);
+ }
+});
+
+
+}, '@VERSION@', {"requires": ["event-base", "node-core", "dom-base", "dom-style"]});