1 /*

     2 Copyright (c) 2009, Yahoo! Inc. All rights reserved.

     3 Code licensed under the BSD License:

     4 http://developer.yahoo.net/yui/license.txt

     5 version: 3.0.0

     6 build: 1549

     7 */

     8 YUI.add('selector-native', function(Y) {

     9 

    10 (function(Y) {

    11 /**

    12  * The selector-native module provides support for native querySelector

    13  * @module dom

    14  * @submodule selector-native

    15  * @for Selector

    16  */

    17 

    18 /**

    19  * Provides support for using CSS selectors to query the DOM 

    20  * @class Selector 

    21  * @static

    22  * @for Selector

    23  */

    24 

    25 Y.namespace('Selector'); // allow native module to standalone

    26 

    27 var COMPARE_DOCUMENT_POSITION = 'compareDocumentPosition',

    28     OWNER_DOCUMENT = 'ownerDocument',

    29     TMP_PREFIX = 'yui-tmp-',

    30     g_counter = 0;

    31 

    32 var Selector = {

    33     _foundCache: [],

    34 

    35     useNative: true,

    36 

    37     _compare: ('sourceIndex' in document.documentElement) ?

    38         function(nodeA, nodeB) {

    39             var a = nodeA.sourceIndex,

    40                 b = nodeB.sourceIndex;

    41 

    42             if (a === b) {

    43                 return 0;

    44             } else if (a > b) {

    45                 return 1;

    46             }

    47 

    48             return -1;

    49 

    50         } : (document.documentElement[COMPARE_DOCUMENT_POSITION] ?

    51         function(nodeA, nodeB) {

    52             if (nodeA[COMPARE_DOCUMENT_POSITION](nodeB) & 4) {

    53                 return -1;

    54             } else {

    55                 return 1;

    56             }

    57         } :

    58         function(nodeA, nodeB) {

    59             var rangeA, rangeB, compare;

    60             if (nodeA && nodeB) {

    61                 rangeA = nodeA[OWNER_DOCUMENT].createRange();

    62                 rangeA.setStart(nodeA, 0);

    63                 rangeB = nodeB[OWNER_DOCUMENT].createRange();

    64                 rangeB.setStart(nodeB, 0);

    65                 compare = rangeA.compareBoundaryPoints(1, rangeB); // 1 === Range.START_TO_END

    66             }

    67 

    68             return compare;

    69         

    70     }),

    71 

    72     _sort: function(nodes) {

    73         if (nodes) {

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

    75             if (nodes.sort) {

    76                 nodes.sort(Selector._compare);

    77             }

    78         }

    79 

    80         return nodes;

    81     },

    82 

    83     _deDupe: function(nodes) {

    84         var ret = [],

    85             i, node;

    86 

    87         for (i = 0; (node = nodes[i++]);) {

    88             if (!node._found) {

    89                 ret[ret.length] = node;

    90                 node._found = true;

    91             }

    92         }

    93 

    94         for (i = 0; (node = ret[i++]);) {

    95             node._found = null;

    96             node.removeAttribute('_found');

    97         }

    98 

    99         return ret;

   100     },

   101 

   102     /**

   103      * Retrieves a set of nodes based on a given CSS selector. 

   104      * @method query

   105      *

   106      * @param {string} selector The CSS Selector to test the node against.

   107      * @param {HTMLElement} root optional An HTMLElement to start the query from. Defaults to Y.config.doc

   108      * @param {Boolean} firstOnly optional Whether or not to return only the first match.

   109      * @return {Array} An array of nodes that match the given selector.

   110      * @static

   111      */

   112     query: function(selector, root, firstOnly, skipNative) {

   113         root = root || Y.config.doc;

   114         var ret = [],

   115             useNative = (Y.Selector.useNative && document.querySelector && !skipNative),

   116             queries = [[selector, root]],

   117             query,

   118             result,

   119             i,

   120             fn = (useNative) ? Y.Selector._nativeQuery : Y.Selector._bruteQuery;

   121 

   122         if (selector && fn) {

   123             // split group into seperate queries

   124             if (!skipNative && // already done if skipping

   125                     (!useNative || root.tagName)) { // split native when element scoping is needed

   126                 queries = Selector._splitQueries(selector, root);

   127             }

   128 

   129             for (i = 0; (query = queries[i++]);) {

   130                 result = fn(query[0], query[1], firstOnly);

   131                 if (!firstOnly) { // coerce DOM Collection to Array

   132                     result = Y.Array(result, 0, true);

   133                 }

   134                 if (result) {

   135                     ret = ret.concat(result);

   136                 }

   137             }

   138 

   139             if (queries.length > 1) { // remove dupes and sort by doc order 

   140                 ret = Selector._sort(Selector._deDupe(ret));

   141             }

   142         }

   143 

   144         Y.log('query: ' + selector + ' returning: ' + ret.length, 'info', 'Selector');

   145         return (firstOnly) ? (ret[0] || null) : ret;

   146 

   147     },

   148 

   149     // allows element scoped queries to begin with combinator

   150     // e.g. query('> p', document.body) === query('body > p')

   151     _splitQueries: function(selector, node) {

   152         var groups = selector.split(','),

   153             queries = [],

   154             prefix = '',

   155             i, len;

   156 

   157         if (node) {

   158             // enforce for element scoping

   159             if (node.tagName) {

   160                 node.id = node.id || Y.guid();

   161                 prefix = '#' + node.id + ' ';

   162             }

   163 

   164             for (i = 0, len = groups.length; i < len; ++i) {

   165                 selector =  prefix + groups[i];

   166                 queries.push([selector, node]);

   167             }

   168         }

   169 

   170         return queries;

   171     },

   172 

   173     _nativeQuery: function(selector, root, one) {

   174         try {

   175             //Y.log('trying native query with: ' + selector, 'info', 'selector-native');

   176             return root['querySelector' + (one ? '' : 'All')](selector);

   177         } catch(e) { // fallback to brute if available

   178             //Y.log('native query error; reverting to brute query with: ' + selector, 'info', 'selector-native');

   179             return Y.Selector.query(selector, root, one, true); // redo with skipNative true

   180         }

   181     },

   182 

   183     filter: function(nodes, selector) {

   184         var ret = [],

   185             i, node;

   186 

   187         if (nodes && selector) {

   188             for (i = 0; (node = nodes[i++]);) {

   189                 if (Y.Selector.test(node, selector)) {

   190                     ret[ret.length] = node;

   191                 }

   192             }

   193         } else {

   194             Y.log('invalid filter input (nodes: ' + nodes +

   195                     ', selector: ' + selector + ')', 'warn', 'Selector');

   196         }

   197 

   198         return ret;

   199     },

   200 

   201     test: function(node, selector, root) {

   202         var ret = false,

   203             groups = selector.split(','),

   204             item,

   205             i, group;

   206 

   207         if (node && node.tagName) { // only test HTMLElements

   208             root = root || node.ownerDocument;

   209 

   210             if (!node.id) {

   211                 node.id = TMP_PREFIX + g_counter++;

   212             }

   213             for (i = 0; (group = groups[i++]);) { // TODO: off-dom test

   214                 group += '#' + node.id; // add ID for uniqueness

   215                 item = Y.Selector.query(group, root, true);

   216                 ret = (item === node);

   217                 if (ret) {

   218                     break;

   219                 }

   220             }

   221         }

   222 

   223         return ret;

   224     }

   225 };

   226 

   227 Y.mix(Y.Selector, Selector, true);

   228 

   229 })(Y);

   230 

   231 

   232 }, '3.0.0' ,{requires:['dom-base']});