jssource/src_files/include/javascript/yui3/build/dom/selector-native.js

   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         return (firstOnly) ? (ret[0] || null) : ret;
 145
 146     },
 147
 148     // allows element scoped queries to begin with combinator
 149     // e.g. query('> p', document.body) === query('body > p')
 150     _splitQueries: function(selector, node) {
 151         var groups = selector.split(','),
 152             queries = [],
 153             prefix = '',
 154             i, len;
 155
 156         if (node) {
 157             // enforce for element scoping
 158             if (node.tagName) {
 159                 node.id = node.id || Y.guid();
 160                 prefix = '#' + node.id + ' ';
 161             }
 162
 163             for (i = 0, len = groups.length; i < len; ++i) {
 164                 selector =  prefix + groups[i];
 165                 queries.push([selector, node]);
 166             }
 167         }
 168
 169         return queries;
 170     },
 171
 172     _nativeQuery: function(selector, root, one) {
 173         try {
 174             return root['querySelector' + (one ? '' : 'All')](selector);
 175         } catch(e) { // fallback to brute if available
 176             return Y.Selector.query(selector, root, one, true); // redo with skipNative true
 177         }
 178     },
 179
 180     filter: function(nodes, selector) {
 181         var ret = [],
 182             i, node;
 183
 184         if (nodes && selector) {
 185             for (i = 0; (node = nodes[i++]);) {
 186                 if (Y.Selector.test(node, selector)) {
 187                     ret[ret.length] = node;
 188                 }
 189             }
 190         } else {
 191         }
 192
 193         return ret;
 194     },
 195
 196     test: function(node, selector, root) {
 197         var ret = false,
 198             groups = selector.split(','),
 199             item,
 200             i, group;
 201
 202         if (node && node.tagName) { // only test HTMLElements
 203             root = root || node.ownerDocument;
 204
 205             if (!node.id) {
 206                 node.id = TMP_PREFIX + g_counter++;
 207             }
 208             for (i = 0; (group = groups[i++]);) { // TODO: off-dom test
 209                 group += '#' + node.id; // add ID for uniqueness
 210                 item = Y.Selector.query(group, root, true);
 211                 ret = (item === node);
 212                 if (ret) {
 213                     break;
 214                 }
 215             }
 216         }
 217
 218         return ret;
 219     }
 220 };
 221
 222 Y.mix(Y.Selector, Selector, true);
 223
 224 })(Y);
 225
 226
 227 }, '3.0.0' ,{requires:['dom-base']});