Proyectos de Subversion Moodle

YUI.add('node-core', function (Y, NAME) {

/**

 * The Node Utility provides a DOM-like interface for interacting with DOM nodes.

 * @module node

 * @main node

 * @submodule node-core

 */

/**

 * The Node class provides a wrapper for manipulating DOM Nodes.

 * Node properties can be accessed via the set/get methods.

 * Use `Y.one()` to retrieve Node instances.

 *

 * <strong>NOTE:</strong> Node properties are accessed using

 * the <code>set</code> and <code>get</code> methods.

 *

 * @class Node

 * @constructor

 * @param {HTMLElement} node the DOM node to be mapped to the Node instance.

 * @uses EventTarget

 */

// "globals"

var DOT = '.',

    NODE_NAME = 'nodeName',

    NODE_TYPE = 'nodeType',

    OWNER_DOCUMENT = 'ownerDocument',

    TAG_NAME = 'tagName',

    UID = '_yuid',

    EMPTY_OBJ = {},

    _slice = Array.prototype.slice,

    Y_DOM = Y.DOM,

    Y_Node = function(node) {

        if (!this.getDOMNode) { // support optional "new"

            return new Y_Node(node);

        }

        if (typeof node == 'string') {

            node = Y_Node._fromString(node);

            if (!node) {

                return null; // NOTE: return

            }

        }

        var uid = (node.nodeType !== 9) ? node.uniqueID : node[UID];

        if (uid && Y_Node._instances[uid] && Y_Node._instances[uid]._node !== node) {

            node[UID] = null; // unset existing uid to prevent collision (via clone or hack)

        }

        uid = uid || Y.stamp(node);

        if (!uid) { // stamp failed; likely IE non-HTMLElement

            uid = Y.guid();

        }

        this[UID] = uid;

        /**

         * The underlying DOM node bound to the Y.Node instance

         * @property _node

         * @type HTMLElement

         * @private

         */

        this._node = node;

        this._stateProxy = node; // when augmented with Attribute

        if (this._initPlugins) { // when augmented with Plugin.Host

            this._initPlugins();

        }

    },

    // used with previous/next/ancestor tests

    _wrapFn = function(fn) {

        var ret = null;

        if (fn) {

            ret = (typeof fn == 'string') ?

            function(n) {

                return Y.Selector.test(n, fn);

            } :

            function(n) {

                return fn(Y.one(n));

            };

        }

        return ret;

    };

// end "globals"

Y_Node.ATTRS = {};

Y_Node.DOM_EVENTS = {};

Y_Node._fromString = function(node) {

    if (node) {

        if (node.indexOf('doc') === 0) { // doc OR document

            node = Y.config.doc;

        } else if (node.indexOf('win') === 0) { // win OR window

            node = Y.config.win;

        } else {

            node = Y.Selector.query(node, null, true);

        }

    }

    return node || null;

};

/**

 * The name of the component

 * @static

 * @type String

 * @property NAME

 */

Y_Node.NAME = 'node';

/*

 * The pattern used to identify ARIA attributes

 */

Y_Node.re_aria = /^(?:role$|aria-)/;

Y_Node.SHOW_TRANSITION = 'fadeIn';

Y_Node.HIDE_TRANSITION = 'fadeOut';

/**

 * A list of Node instances that have been created

 * @private

 * @type Object

 * @property _instances

 * @static

 *

 */

Y_Node._instances = {};

/**

 * Retrieves the DOM node bound to a Node instance

 * @method getDOMNode

 * @static

 *

 * @param {Node|HTMLElement} node The Node instance or an HTMLElement

 * @return {HTMLElement} The DOM node bound to the Node instance.  If a DOM node is passed

 * as the node argument, it is simply returned.

 */

Y_Node.getDOMNode = function(node) {

    if (node) {

        return (node.nodeType) ? node : node._node || null;

    }

    return null;

};

/**

 * Checks Node return values and wraps DOM Nodes as Y.Node instances

 * and DOM Collections / Arrays as Y.NodeList instances.

 * Other return values just pass thru.  If undefined is returned (e.g. no return)

 * then the Node instance is returned for chainability.

 * @method scrubVal

 * @static

 *

 * @param {HTMLElement|HTMLElement[]|Node} node The Node instance or an HTMLElement

 * @return {Node | NodeList | Any} Depends on what is returned from the DOM node.

 */

Y_Node.scrubVal = function(val, node) {

    if (val) { // only truthy values are risky

         if (typeof val == 'object' || typeof val == 'function') { // safari nodeList === function

            if (NODE_TYPE in val || Y_DOM.isWindow(val)) {// node || window

                val = Y.one(val);

            } else if ((val.item && !val._nodes) || // dom collection or Node instance

                    (val[0] && val[0][NODE_TYPE])) { // array of DOM Nodes

                val = Y.all(val);

            }

        }

    } else if (typeof val === 'undefined') {

        val = node; // for chaining

    } else if (val === null) {

        val = null; // IE: DOM null not the same as null

    }

    return val;

};

/**

 * Adds methods to the Y.Node prototype, routing through scrubVal.

 * @method addMethod

 * @static

 *

 * @param {String} name The name of the method to add

 * @param {Function} fn The function that becomes the method

 * @param {Object} context An optional context to call the method with

 * (defaults to the Node instance)

 * @return {any} Depends on what is returned from the DOM node.

 */

Y_Node.addMethod = function(name, fn, context) {

    if (name && fn && typeof fn == 'function') {

        Y_Node.prototype[name] = function() {

            var args = _slice.call(arguments),

                node = this,

                ret;

            if (args[0] && args[0]._node) {

                args[0] = args[0]._node;

            }

            if (args[1] && args[1]._node) {

                args[1] = args[1]._node;

            }

            args.unshift(node._node);

            ret = fn.apply(context || node, args);

            if (ret) { // scrub truthy

                ret = Y_Node.scrubVal(ret, node);

            }

            (typeof ret != 'undefined') || (ret = node);

            return ret;

        };

    } else {

    }

};

/**

 * Imports utility methods to be added as Y.Node methods.

 * @method importMethod

 * @static

 *

 * @param {Object} host The object that contains the method to import.

 * @param {String} name The name of the method to import

 * @param {String} altName An optional name to use in place of the host name

 * @param {Object} context An optional context to call the method with

 */

Y_Node.importMethod = function(host, name, altName) {

    if (typeof name == 'string') {

        altName = altName || name;

        Y_Node.addMethod(altName, host[name], host);

    } else {

        Y.Array.each(name, function(n) {

            Y_Node.importMethod(host, n);

        });

    }

};

/**

 * Retrieves a NodeList based on the given CSS selector.

 * @method all

 *

 * @param {string} selector The CSS selector to test against.

 * @return {NodeList} A NodeList instance for the matching HTMLCollection/Array.

 * @for YUI

 */

/**

 * Returns a single Node instance bound to the node or the

 * first element matching the given selector. Returns null if no match found.

 * <strong>Note:</strong> For chaining purposes you may want to

 * use <code>Y.all</code>, which returns a NodeList when no match is found.

 * @method one

 * @param {String | HTMLElement} node a node or Selector

 * @return {Node | null} a Node instance or null if no match found.

 * @for YUI

 */

/**

 * Returns a single Node instance bound to the node or the

 * first element matching the given selector. Returns null if no match found.

 * <strong>Note:</strong> For chaining purposes you may want to

 * use <code>Y.all</code>, which returns a NodeList when no match is found.

 * @method one

 * @static

 * @param {String | HTMLElement} node a node or Selector

 * @return {Node | null} a Node instance or null if no match found.

 * @for Node

 */

Y_Node.one = function(node) {

    var instance = null,

        cachedNode,

        uid;

    if (node) {

        if (typeof node == 'string') {

            node = Y_Node._fromString(node);

            if (!node) {

                return null; // NOTE: return

            }

        } else if (node.getDOMNode) {

            return node; // NOTE: return

        }

        if (node.nodeType || Y.DOM.isWindow(node)) { // avoid bad input (numbers, boolean, etc)

            uid = (node.uniqueID && node.nodeType !== 9) ? node.uniqueID : node._yuid;

            instance = Y_Node._instances[uid]; // reuse exising instances

            cachedNode = instance ? instance._node : null;

            if (!instance || (cachedNode && node !== cachedNode)) { // new Node when nodes don't match

                instance = new Y_Node(node);

                if (node.nodeType != 11) { // dont cache document fragment

                    Y_Node._instances[instance[UID]] = instance; // cache node

                }

            }

        }

    }

    return instance;

};

/**

 * The default setter for DOM properties

 * Called with instance context (this === the Node instance)

 * @method DEFAULT_SETTER

 * @static

 * @param {String} name The attribute/property being set

 * @param {any} val The value to be set

 * @return {any} The value

 */

Y_Node.DEFAULT_SETTER = function(name, val) {

    var node = this._stateProxy,

        strPath;

    if (name.indexOf(DOT) > -1) {

        strPath = name;

        name = name.split(DOT);

        // only allow when defined on node

        Y.Object.setValue(node, name, val);

    } else if (typeof node[name] != 'undefined') { // pass thru DOM properties

        node[name] = val;

    }

    return val;

};

/**

 * The default getter for DOM properties

 * Called with instance context (this === the Node instance)

 * @method DEFAULT_GETTER

 * @static

 * @param {String} name The attribute/property to look up

 * @return {any} The current value

 */

Y_Node.DEFAULT_GETTER = function(name) {

    var node = this._stateProxy,

        val;

    if (name.indexOf && name.indexOf(DOT) > -1) {

        val = Y.Object.getValue(node, name.split(DOT));

    } else if (typeof node[name] != 'undefined') { // pass thru from DOM

        val = node[name];

    }

    return val;

};

Y.mix(Y_Node.prototype, {

    DATA_PREFIX: 'data-',

    /**

     * The method called when outputting Node instances as strings

     * @method toString

     * @return {String} A string representation of the Node instance

     */

    toString: function() {

        var str = this[UID] + ': not bound to a node',

            node = this._node,

            attrs, id, className;

        if (node) {

            attrs = node.attributes;

            id = (attrs && attrs.id) ? node.getAttribute('id') : null;

            className = (attrs && attrs.className) ? node.getAttribute('className') : null;

            str = node[NODE_NAME];

            if (id) {

                str += '#' + id;

            }

            if (className) {

                str += '.' + className.replace(' ', '.');

            }

            // TODO: add yuid?

            str += ' ' + this[UID];

        }

        return str;

    },

    /**

     * Returns an attribute value on the Node instance.

     * Unless pre-configured (via `Node.ATTRS`), get hands

     * off to the underlying DOM node.  Only valid

     * attributes/properties for the node will be queried.

     * @method get

     * @param {String} attr The attribute

     * @return {any} The current value of the attribute

     */

    get: function(attr) {

        var val;

        if (this._getAttr) { // use Attribute imple

            val = this._getAttr(attr);

        } else {

            val = this._get(attr);

        }

        if (val) {

            val = Y_Node.scrubVal(val, this);

        } else if (val === null) {

            val = null; // IE: DOM null is not true null (even though they ===)

        }

        return val;

    },

    /**

     * Helper method for get.

     * @method _get

     * @private

     * @param {String} attr The attribute

     * @return {any} The current value of the attribute

     */

    _get: function(attr) {

        var attrConfig = Y_Node.ATTRS[attr],

            val;

        if (attrConfig && attrConfig.getter) {

            val = attrConfig.getter.call(this);

        } else if (Y_Node.re_aria.test(attr)) {

            val = this._node.getAttribute(attr, 2);

        } else {

            val = Y_Node.DEFAULT_GETTER.apply(this, arguments);

        }

        return val;

    },

    /**

     * Sets an attribute on the Node instance.

     * Unless pre-configured (via Node.ATTRS), set hands

     * off to the underlying DOM node.  Only valid

     * attributes/properties for the node will be set.

     * To set custom attributes use setAttribute.

     * @method set

     * @param {String} attr The attribute to be set.

     * @param {any} val The value to set the attribute to.

     * @chainable

     */

    set: function(attr, val) {

        var attrConfig = Y_Node.ATTRS[attr];

        if (this._setAttr) { // use Attribute imple

            this._setAttr.apply(this, arguments);

        } else { // use setters inline

            if (attrConfig && attrConfig.setter) {

                attrConfig.setter.call(this, val, attr);

            } else if (Y_Node.re_aria.test(attr)) { // special case Aria

                this._node.setAttribute(attr, val);

            } else {

                Y_Node.DEFAULT_SETTER.apply(this, arguments);

            }

        }

        return this;

    },

    /**

     * Sets multiple attributes.

     * @method setAttrs

     * @param {Object} attrMap an object of name/value pairs to set

     * @chainable

     */

    setAttrs: function(attrMap) {

        if (this._setAttrs) { // use Attribute imple

            this._setAttrs(attrMap);

        } else { // use setters inline

            Y.Object.each(attrMap, function(v, n) {

                this.set(n, v);

            }, this);

        }

        return this;

    },

    /**

     * Returns an object containing the values for the requested attributes.

     * @method getAttrs

     * @param {Array} attrs an array of attributes to get values

     * @return {Object} An object with attribute name/value pairs.

     */

    getAttrs: function(attrs) {

        var ret = {};

        if (this._getAttrs) { // use Attribute imple

            this._getAttrs(attrs);

        } else { // use setters inline

            Y.Array.each(attrs, function(v, n) {

                ret[v] = this.get(v);

            }, this);

        }

        return ret;

    },

    /**

     * Compares nodes to determine if they match.

     * Node instances can be compared to each other and/or HTMLElements.

     * @method compareTo

     * @param {HTMLElement | Node} refNode The reference node to compare to the node.

     * @return {Boolean} True if the nodes match, false if they do not.

     */

    compareTo: function(refNode) {

        var node = this._node;

        if (refNode && refNode._node) {

            refNode = refNode._node;

        }

        return node === refNode;

    },

    /**

     * Determines whether the node is appended to the document.

     * @method inDoc

     * @param {Node|HTMLElement} doc optional An optional document to check against.

     * Defaults to current document.

     * @return {Boolean} Whether or not this node is appended to the document.

     */

    inDoc: function(doc) {

        var node = this._node;

        if (node) {

            doc = (doc) ? doc._node || doc : node[OWNER_DOCUMENT];

            if (doc.documentElement) {

                return Y_DOM.contains(doc.documentElement, node);

            }

        }

        return false;

    },

    getById: function(id) {

        var node = this._node,

            ret = Y_DOM.byId(id, node[OWNER_DOCUMENT]);

        if (ret && Y_DOM.contains(node, ret)) {

            ret = Y.one(ret);

        } else {

            ret = null;

        }

        return ret;

    },

   /**

     * Returns the nearest ancestor that passes the test applied by supplied boolean method.

     * @method ancestor

     * @param {String | Function} fn A selector string or boolean method for testing elements.

     * If a function is used, it receives the current node being tested as the only argument.

     * If fn is not passed as an argument, the parent node will be returned.

     * @param {Boolean} testSelf optional Whether or not to include the element in the scan

     * @param {String | Function} stopFn optional A selector string or boolean

     * method to indicate when the search should stop. The search bails when the function

     * returns true or the selector matches.

     * If a function is used, it receives the current node being tested as the only argument.

     * @return {Node} The matching Node instance or null if not found

     */

    ancestor: function(fn, testSelf, stopFn) {

        // testSelf is optional, check for stopFn as 2nd arg

        if (arguments.length === 2 &&

                (typeof testSelf == 'string' || typeof testSelf == 'function')) {

            stopFn = testSelf;

        }

        return Y.one(Y_DOM.ancestor(this._node, _wrapFn(fn), testSelf, _wrapFn(stopFn)));

    },

   /**

     * Returns the ancestors that pass the test applied by supplied boolean method.

     * @method ancestors

     * @param {String | Function} fn A selector string or boolean method for testing elements.

     * @param {Boolean} testSelf optional Whether or not to include the element in the scan

     * If a function is used, it receives the current node being tested as the only argument.

     * @return {NodeList} A NodeList instance containing the matching elements

     */

    ancestors: function(fn, testSelf, stopFn) {

        if (arguments.length === 2 &&

                (typeof testSelf == 'string' || typeof testSelf == 'function')) {

            stopFn = testSelf;

        }

        return Y.all(Y_DOM.ancestors(this._node, _wrapFn(fn), testSelf, _wrapFn(stopFn)));

    },

    /**

     * Returns the previous matching sibling.

     * Returns the nearest element node sibling if no method provided.

     * @method previous

     * @param {String | Function} fn A selector or boolean method for testing elements.

     * If a function is used, it receives the current node being tested as the only argument.

     * @param {Boolean} [all] Whether text nodes as well as element nodes should be returned, or

     * just element nodes will be returned(default)

     * @return {Node} Node instance or null if not found

     */

    previous: function(fn, all) {

        return Y.one(Y_DOM.elementByAxis(this._node, 'previousSibling', _wrapFn(fn), all));

    },

    /**

     * Returns the next matching sibling.

     * Returns the nearest element node sibling if no method provided.

     * @method next

     * @param {String | Function} fn A selector or boolean method for testing elements.

     * If a function is used, it receives the current node being tested as the only argument.

     * @param {Boolean} [all] Whether text nodes as well as element nodes should be returned, or

     * just element nodes will be returned(default)

     * @return {Node} Node instance or null if not found

     */

    next: function(fn, all) {

        return Y.one(Y_DOM.elementByAxis(this._node, 'nextSibling', _wrapFn(fn), all));

    },

    /**

     * Returns all matching siblings.

     * Returns all siblings if no method provided.

     * @method siblings

     * @param {String | Function} fn A selector or boolean method for testing elements.

     * If a function is used, it receives the current node being tested as the only argument.

     * @return {NodeList} NodeList instance bound to found siblings

     */

    siblings: function(fn) {

        return Y.all(Y_DOM.siblings(this._node, _wrapFn(fn)));

    },

    /**

     * Retrieves a single Node instance, the first element matching the given

     * CSS selector.

     * Returns null if no match found.

     * @method one

     *

     * @param {string} selector The CSS selector to test against.

     * @return {Node | null} A Node instance for the matching HTMLElement or null

     * if no match found.

     */

    one: function(selector) {

        return Y.one(Y.Selector.query(selector, this._node, true));

    },

    /**

     * Retrieves a NodeList based on the given CSS selector.

     * @method all

     *

     * @param {string} selector The CSS selector to test against.

     * @return {NodeList} A NodeList instance for the matching HTMLCollection/Array.

     */

    all: function(selector) {

        var nodelist;

        if (this._node) {

            nodelist = Y.all(Y.Selector.query(selector, this._node));

            nodelist._query = selector;

            nodelist._queryRoot = this._node;

        }

        return nodelist || Y.all([]);

    },

    // TODO: allow fn test

    /**

     * Test if the supplied node matches the supplied selector.

     * @method test

     *

     * @param {string} selector The CSS selector to test against.

     * @return {boolean} Whether or not the node matches the selector.

     */

    test: function(selector) {

        return Y.Selector.test(this._node, selector);

    },

    /**

     * Removes the node from its parent.

     * Shortcut for myNode.get('parentNode').removeChild(myNode);

     * @method remove

     * @param {Boolean} destroy whether or not to call destroy() on the node

     * after removal.

     * @chainable

     *

     */

    remove: function(destroy) {

        var node = this._node;

        if (node && node.parentNode) {

            node.parentNode.removeChild(node);

        }

        if (destroy) {

            this.destroy();

        }

        return this;

    },

    /**

     * Replace the node with the other node. This is a DOM update only

     * and does not change the node bound to the Node instance.

     * Shortcut for myNode.get('parentNode').replaceChild(newNode, myNode);

     * @method replace

     * @param {Node | HTMLElement} newNode Node to be inserted

     * @chainable

     *

     */

    replace: function(newNode) {

        var node = this._node;

        if (typeof newNode == 'string') {

            newNode = Y_Node.create(newNode);

        }

        node.parentNode.replaceChild(Y_Node.getDOMNode(newNode), node);

        return this;

    },

    /**

     * @method replaceChild

     * @for Node

     * @param {String | HTMLElement | Node} node Node to be inserted

     * @param {HTMLElement | Node} refNode Node to be replaced

     * @return {Node} The replaced node

     */

    replaceChild: function(node, refNode) {

        if (typeof node == 'string') {

            node = Y_DOM.create(node);

        }

        return Y.one(this._node.replaceChild(Y_Node.getDOMNode(node), Y_Node.getDOMNode(refNode)));

    },

    /**

     * Nulls internal node references, removes any plugins and event listeners.

     * Note that destroy() will not remove the node from its parent or from the DOM. For that

     * functionality, call remove(true).

     * @method destroy

     * @param {Boolean} recursivePurge (optional) Whether or not to remove listeners from the

     * node's subtree (default is false)

     *

     */

    destroy: function(recursive) {

        var UID = Y.config.doc.uniqueID ? 'uniqueID' : '_yuid',

            instance;

        this.purge(); // TODO: only remove events add via this Node

        if (this.unplug) { // may not be a PluginHost

            this.unplug();

        }

        this.clearData();

        if (recursive) {

            Y.NodeList.each(this.all('*'), function(node) {

                instance = Y_Node._instances[node[UID]];

                if (instance) {

                   instance.destroy();

                } else { // purge in case added by other means

                    Y.Event.purgeElement(node);

                }

            });

        }

        this._node = null;

        this._stateProxy = null;

        delete Y_Node._instances[this._yuid];

    },

    /**

     * Invokes a method on the Node instance

     * @method invoke

     * @param {String} method The name of the method to invoke

     * @param {any} [args*] Arguments to invoke the method with.

     * @return {any} Whatever the underly method returns.

     * DOM Nodes and Collections return values

     * are converted to Node/NodeList instances.

     *

     */

    invoke: function(method, a, b, c, d, e) {

        var node = this._node,

            ret;

        if (a && a._node) {

            a = a._node;

        }

        if (b && b._node) {

            b = b._node;

        }

        ret = node[method](a, b, c, d, e);

        return Y_Node.scrubVal(ret, this);

    },

    /**

    * @method swap

    * @description Swap DOM locations with the given node.

    * This does not change which DOM node each Node instance refers to.

    * @param {Node} otherNode The node to swap with

     * @chainable

    */

    swap: Y.config.doc.documentElement.swapNode ?

        function(otherNode) {

            this._node.swapNode(Y_Node.getDOMNode(otherNode));

        } :

        function(otherNode) {

            otherNode = Y_Node.getDOMNode(otherNode);

            var node = this._node,

                parent = otherNode.parentNode,

                nextSibling = otherNode.nextSibling;

            if (nextSibling === node) {

                parent.insertBefore(node, otherNode);

            } else if (otherNode === node.nextSibling) {

                parent.insertBefore(otherNode, node);

            } else {

                node.parentNode.replaceChild(otherNode, node);

                Y_DOM.addHTML(parent, node, nextSibling);

            }

            return this;

        },

    hasMethod: function(method) {

        var node = this._node;

        return !!(node && method in node &&

                typeof node[method] != 'unknown' &&

            (typeof node[method] == 'function' ||

                String(node[method]).indexOf('function') === 1)); // IE reports as object, prepends space

    },

    isFragment: function() {

        return (this.get('nodeType') === 11);

    },

    /**

     * Removes and destroys all of the nodes within the node.

     * @method empty

     * @chainable

     */

    empty: function() {

        this.get('childNodes').remove().destroy(true);

        return this;

    },

    /**

     * Returns the DOM node bound to the Node instance

     * @method getDOMNode

     * @return {HTMLElement}

     */

    getDOMNode: function() {

        return this._node;

    }

}, true);

Y.Node = Y_Node;

Y.one = Y_Node.one;

/**

 * The NodeList module provides support for managing collections of Nodes.

 * @module node

 * @submodule node-core

 */

/**

 * The NodeList class provides a wrapper for manipulating DOM NodeLists.

 * NodeList properties can be accessed via the set/get methods.

 * Use Y.all() to retrieve NodeList instances.

 *

 * @class NodeList

 * @constructor

 * @param nodes {String|element|Node|Array} A selector, DOM element, Node, list of DOM elements, or list of Nodes with which to populate this NodeList.

 */

var NodeList = function(nodes) {

    var tmp = [];

    if (nodes) {

        if (typeof nodes === 'string') { // selector query

            this._query = nodes;

            nodes = Y.Selector.query(nodes);

        } else if (nodes.nodeType || Y_DOM.isWindow(nodes)) { // domNode || window

            nodes = [nodes];

        } else if (nodes._node) { // Y.Node

            nodes = [nodes._node];

        } else if (nodes[0] && nodes[0]._node) { // allow array of Y.Nodes

            Y.Array.each(nodes, function(node) {

                if (node._node) {

                    tmp.push(node._node);

                }

            });

            nodes = tmp;

        } else { // array of domNodes or domNodeList (no mixed array of Y.Node/domNodes)

            nodes = Y.Array(nodes, 0, true);

        }

    }

    /**

     * The underlying array of DOM nodes bound to the Y.NodeList instance

     * @property _nodes

     * @private

     */

    this._nodes = nodes || [];

};

NodeList.NAME = 'NodeList';

/**

 * Retrieves the DOM nodes bound to a NodeList instance

 * @method getDOMNodes

 * @static

 *

 * @param {NodeList} nodelist The NodeList instance

 * @return {Array} The array of DOM nodes bound to the NodeList

 */

NodeList.getDOMNodes = function(nodelist) {

    return (nodelist && nodelist._nodes) ? nodelist._nodes : nodelist;

};

NodeList.each = function(instance, fn, context) {

    var nodes = instance._nodes;

    if (nodes && nodes.length) {

        Y.Array.each(nodes, fn, context || instance);

    } else {

    }

};

NodeList.addMethod = function(name, fn, context) {

    if (name && fn) {

        NodeList.prototype[name] = function() {

            var ret = [],

                args = arguments;

            Y.Array.each(this._nodes, function(node) {

                var UID = (node.uniqueID && node.nodeType !== 9 ) ? 'uniqueID' : '_yuid',

                    instance = Y.Node._instances[node[UID]],

                    ctx,

                    result;

                if (!instance) {

                    instance = NodeList._getTempNode(node);

                }

                ctx = context || instance;

                result = fn.apply(ctx, args);

                if (result !== undefined && result !== instance) {

                    ret[ret.length] = result;

                }

            });

            // TODO: remove tmp pointer

            return ret.length ? ret : this;

        };

    } else {

    }

};

/**

 * Import the named method, or methods from the host onto NodeList.

 *

 * @method importMethod

 * @static

 * @param {Object} host The object containing the methods to copy. Typically a prototype.

 * @param {String|String[]} name The name, or an Array of names of the methods to import onto NodeList.

 * @param {String} [altName] An alternative name to use for the method added to NodeList, which may differ from the name

 * of the original host object. Has no effect if <em>name</em> is an array of method names.

 */

NodeList.importMethod = function(host, name, altName) {

    if (typeof name === 'string') {

        altName = altName || name;

        NodeList.addMethod(altName, host[name]);

    } else {

        Y.Array.each(name, function(n) {

            NodeList.importMethod(host, n);

        });

    }

};

NodeList._getTempNode = function(node) {

    var tmp = NodeList._tempNode;

    if (!tmp) {

        tmp = Y.Node.create('<div></div>');

        NodeList._tempNode = tmp;

    }

    tmp._node = node;

    tmp._stateProxy = node;

    return tmp;

};

Y.mix(NodeList.prototype, {

    _invoke: function(method, args, getter) {

        var ret = (getter) ? [] : this;

        this.each(function(node) {

            var val = node[method].apply(node, args);

            if (getter) {

                ret.push(val);

            }

        });

        return ret;

    },

    /**

     * Retrieves the Node instance at the given index.

     * @method item

     *

     * @param {Number} index The index of the target Node.

     * @return {Node} The Node instance at the given index.