Class NodeList
                        
                        
                    
                    
                    
                
  
                    
                        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.
                    
                        
                    
                    
                        
                            Properties
                            
                                    
                                    _nodes
                                        - private object
                                    
                                    
                                        
                                            The underlying array of DOM nodes bound to the Y.NodeList instance
                                        
                                     
     
                                        
                                    
                                     
                             
                         
                     
                    
                        
                            Methods
                            
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            addClass
                                           (
                                                
                                                        
                                                         className
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Adds a class name to each node.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        className
                                                        <String>
                                                        the class name to add to the node's class attribute
                                                Chainable: This method is chainable.
                                            
        
             
                                         
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Object
                                            after
                                           (
                                                
                                                        
                                                         type
                                                    
                                                
                                                        , 
                                                         fn
                                                    
                                                
                                                        , 
                                                         context
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            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.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        type
                                                        <String>
                                                        The event being listened for
- 
                                                        fn
                                                        <Function>
                                                        The handler to call when the event fires
- 
                                                        context
                                                        <Object>
                                                        The context to call the handler with.
Default is the NodeList instance.
                                                    - Returns:
                                                    
                                                            Object
                                                    
- Returns an event handle that can later be use to detach().
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            append
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            detach
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            detachAll
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            each
                                           (
                                                
                                                        
                                                         fn
                                                    
                                                
                                                        , 
                                                         context
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Applies the given function to each Node in the NodeList.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        fn
                                                        <Function>
                                                        The function to apply. It receives 3 arguments:
the current node instance, the node's index, and the NodeList instance
- 
                                                        context
                                                        <Object>
                                                        optional An optional context to apply the function with
Default context is the current Node instance
                                                Chainable: This method is chainable.
                                            
        
             
                                         
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        NodeList
                                            even
                                           (
                                            )
                                        
                                        
                                        
                                            Creates a new NodeList containing all nodes at even indices
(zero-based index), including zero.
                                        
                                        
                                                
                                                    - Returns:
                                                    
                                                            NodeList
                                                    
- NodeList containing the updated collection
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        NodeList
                                            filter
                                           (
                                                
                                                        
                                                         selector
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Filters the NodeList instance down to only nodes matching the given selector.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        selector
                                                        <String>
                                                        The selector to filter against
                                                    - Returns:
                                                    
                                                            NodeList
                                                    
- NodeList containing the updated collection
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            get
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        string
                                            getAttribute
                                           (
                                                
                                                        
                                                         name
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Allows getting attributes on DOM nodes, normalizing in some cases.
This passes through to the DOM node, allowing for custom attributes.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        name
                                                        <string>
                                                        The attribute name
                                                    - Returns:
                                                    
                                                            string
                                                    
- The attribute value
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Array
                                            getComputedStyle
                                           (
                                                
                                                        
                                                         attr
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Returns an array of the computed value for each node.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        attr
                                                        <String>
                                                        The style attribute to retrieve.
                                                    - Returns:
                                                    
                                                            Array
                                                    
- The computed values for each node.
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Array
                                            getStyle
                                           (
                                                
                                                        
                                                         attr
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Returns an array of values for each node.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        attr
                                                        <String>
                                                        The style attribute to retrieve.
                                                    - Returns:
                                                    
                                                            Array
                                                    
- The current values of the style property for the element.
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Array
                                            hasClass
                                           (
                                                
                                                        
                                                         className
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Determines whether each node has the given className.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        className
                                                        <String>
                                                        the class name to search for
                                                    - Returns:
                                                    
                                                            Array
                                                    
- An array of booleans for each node bound to the NodeList.
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Int
                                            indexOf
                                           (
                                                
                                                        
                                                         node
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Returns the index of the node in the NodeList instance
or -1 if the node isn't found.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        node
                                                        <Y.Node || DOMNode>
                                                        the node to search for
                                                    - Returns:
                                                    
                                                            Int
                                                    
- the index of the node value or -1 if not found
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            insert
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Boolean
                                            isEmpty
                                           (
                                            )
                                        
                                        
                                        
                                            Determines if the instance is bound to any nodes
                                        
                                        
                                                
                                                    - Returns:
                                                    
                                                            Boolean
                                                    
- Whether or not the NodeList is bound to any nodes
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Node
                                            item
                                           (
                                                
                                                        
                                                         index
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Retrieves the Node instance at the given index.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        index
                                                        <Number>
                                                        The index of the target Node.
                                                    - Returns:
                                                    
                                                            Node
                                                    
- The Node instance at the given index.
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        NodeList
                                            modulus
                                           (
                                                
                                                        
                                                         n
                                                    
                                                
                                                        , 
                                                         r
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Creates a new NodeList containing all nodes at every n indices, where 
remainder n % index equals r.
(zero-based index).
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        n
                                                        <Int>
                                                        The offset to use (return every nth node)
- 
                                                        r
                                                        <Int>
                                                        An optional remainder to use with the modulus operation (defaults to zero)
                                                    - Returns:
                                                    
                                                            NodeList
                                                    
- NodeList containing the updated collection
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                         static 
                                        
                                        void
                                            Node.plug
                                           (
                                                
                                                        
                                                         plugin
                                                    
                                                
                                                        , 
                                                         config
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Registers plugins to be instantiated at the class level (plugins 
which should be plugged into every instance of Node by default).
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        plugin
                                                        <Function | Array>
                                                        Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)
- 
                                                        config
                                                        <Object>
                                                        (Optional) If plugin is the plugin class, the configuration for the plugin
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                         static 
                                        
                                        void
                                            Node.unplug
                                           (
                                                
                                                        
                                                         plugin
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Unregisters any class level plugins which have been registered by the Node
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        plugin
                                                        <Function | Array>
                                                        The plugin class, or an array of plugin classes
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                         static 
                                        
                                        Array
                                            NodeList.getDOMNodes
                                           (
                                                
                                                        
                                                         node
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Retrieves the DOM nodes bound to a NodeList instance
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        node
                                                        <Y.NodeList>
                                                        The NodeList instance
                                                    - Returns:
                                                    
                                                            Array
                                                    
- The array of DOM nodes bound to the NodeList
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        NodeList
                                            odd
                                           (
                                            )
                                        
                                        
                                        
                                            Creates a new NodeList containing all nodes at odd indices
(zero-based index).
                                        
                                        
                                                
                                                    - Returns:
                                                    
                                                            NodeList
                                                    
- NodeList containing the updated collection
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Object
                                            on
                                           (
                                                
                                                        
                                                         type
                                                    
                                                
                                                        , 
                                                         fn
                                                    
                                                
                                                        , 
                                                         context
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Applies an event listener to each Node bound to the NodeList.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        type
                                                        <String>
                                                        The event being listened for
- 
                                                        fn
                                                        <Function>
                                                        The handler to call when the event fires
- 
                                                        context
                                                        <Object>
                                                        The context to call the handler with.
Default is the NodeList instance.
                                                    - Returns:
                                                    
                                                            Object
                                                    
- Returns an event handle that can later be use to detach().
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            prepend
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            refresh
                                           (
                                            )
                                        
                                        
                                        
                                            Reruns the initial query, when created using a selector query
                                        
                                        
                                            
                                                Chainable: This method is chainable.
                                            
        
             
                                         
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            remove
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            removeAttribute
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            removeClass
                                           (
                                                
                                                        
                                                         className
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Removes a class name from each node.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        className
                                                        <String>
                                                        the class name to remove from the node's class attribute
                                                Chainable: This method is chainable.
                                            
        
             
                                         
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            replaceClass
                                           (
                                                
                                                        
                                                         oldClassName
                                                    
                                                
                                                        , 
                                                         newClassName
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Replace a class with another class for each node.
If no oldClassName is present, the newClassName is simply added.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        oldClassName
                                                        <String>
                                                        the class name to be replaced
- 
                                                        newClassName
                                                        <String>
                                                        the class name that will be replacing the old class name
                                                Chainable: This method is chainable.
                                            
        
             
                                         
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            set
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            setAttribute
                                           (
                                                
                                                        
                                                         name
                                                    
                                                
                                                        , 
                                                         value
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Allows setting attributes on DOM nodes, normalizing in some cases.
This passes through to the DOM node, allowing for custom attributes.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        name
                                                        <string>
                                                        The attribute name
- 
                                                        value
                                                        <string>
                                                        The value to set
                                                Chainable: This method is chainable.
                                            
        
             
                                         
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            setContent
                                           (
                                            )
                                        
                                        
                                        
                                            Called on each Node instance
                                        
                                        
             
                                        
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            setStyle
                                           (
                                                
                                                        
                                                         attr
                                                    
                                                
                                                        , 
                                                         val
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Sets a style property on each node.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        attr
                                                        <String>
                                                        The style attribute to set.
- 
                                                        val
                                                        <String|Number>
                                                        The value.
                                                Chainable: This method is chainable.
                                            
        
             
                                         
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            setStyles
                                           (
                                                
                                                        
                                                         hash
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Sets multiple style properties on each node.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        hash
                                                        <Object>
                                                        An object literal of property:value pairs.
                                                Chainable: This method is chainable.
                                            
        
             
                                         
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Int
                                            size
                                           (
                                            )
                                        
                                        
                                        
                                            Returns the current number of items in the NodeList.
                                        
                                        
                                                
                                                    - Returns:
                                                    
                                                            Int
                                                    
- The number of items in the NodeList.
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        Boolean
                                            some
                                           (
                                                
                                                        
                                                         fn
                                                    
                                                
                                                        , 
                                                         context
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            Executes the function once for each node until a true value is returned.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        fn
                                                        <Function>
                                                        The function to apply. It receives 3 arguments:
the current node instance, the node's index, and the NodeList instance
- 
                                                        context
                                                        <Object>
                                                        optional An optional context to execute the function from.
Default context is the current Node instance
                                                    - Returns:
                                                    
                                                            Boolean
                                                    
- Whether or not the function returned true for any node.
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        
                                            toFrag
                                           (
                                            )
                                        
                                        
                                        
                                            Creates a documenFragment from the nodes bound to the NodeList instance
                                        
                                        
                                                
                                                    - Returns:
                                                    
                                                    
- Node a Node instance bound to the documentFragment
 
                                     
                                    
                                     
                                    
                                    
                                    
                                        
                                        
                                        
                                        
                                        void
                                            toggleClass
                                           (
                                                
                                                        
                                                         className
                                                    
                                                
                                            )
                                        
                                        
                                        
                                            If the className exists on the node it is removed, if it doesn't exist it is added.
                                        
                                        
                                                
                                                    - Parameters:
- 
                                                        className
                                                        <String>
                                                        the class name to be toggled
                                                Chainable: This method is chainable.