diff options
Diffstat (limited to 'lib/dojo/query.js.uncompressed.js')
| -rw-r--r-- | lib/dojo/query.js.uncompressed.js | 705 |
1 files changed, 0 insertions, 705 deletions
diff --git a/lib/dojo/query.js.uncompressed.js b/lib/dojo/query.js.uncompressed.js deleted file mode 100644 index bcd5d2456..000000000 --- a/lib/dojo/query.js.uncompressed.js +++ /dev/null @@ -1,705 +0,0 @@ -define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array", "./_base/lang", "./selector/_loader", "./selector/_loader!default"], - function(dojo, has, dom, on, array, lang, loader, defaultEngine){ - - "use strict"; - - has.add("array-extensible", function(){ - // test to see if we can extend an array (not supported in old IE) - return lang.delegate([], {length: 1}).length == 1 && !has("bug-for-in-skips-shadowed"); - }); - - var ap = Array.prototype, aps = ap.slice, apc = ap.concat, forEach = array.forEach; - - var tnl = function(/*Array*/ a, /*dojo/NodeList?*/ parent, /*Function?*/ NodeListCtor){ - // summary: - // decorate an array to make it look like a `dojo/NodeList`. - // a: - // Array of nodes to decorate. - // parent: - // An optional parent NodeList that generated the current - // list of nodes. Used to call _stash() so the parent NodeList - // can be accessed via end() later. - // NodeListCtor: - // An optional constructor function to use for any - // new NodeList calls. This allows a certain chain of - // NodeList calls to use a different object than dojo/NodeList. - var nodeList = new (NodeListCtor || this._NodeListCtor || nl)(a); - return parent ? nodeList._stash(parent) : nodeList; - }; - - var loopBody = function(f, a, o){ - a = [0].concat(aps.call(a, 0)); - o = o || dojo.global; - return function(node){ - a[0] = node; - return f.apply(o, a); - }; - }; - - // adapters - - var adaptAsForEach = function(f, o){ - // summary: - // adapts a single node function to be used in the forEach-type - // actions. The initial object is returned from the specialized - // function. - // f: Function - // a function to adapt - // o: Object? - // an optional context for f - return function(){ - this.forEach(loopBody(f, arguments, o)); - return this; // Object - }; - }; - - var adaptAsMap = function(f, o){ - // summary: - // adapts a single node function to be used in the map-type - // actions. The return is a new array of values, as via `dojo.map` - // f: Function - // a function to adapt - // o: Object? - // an optional context for f - return function(){ - return this.map(loopBody(f, arguments, o)); - }; - }; - - var adaptAsFilter = function(f, o){ - // summary: - // adapts a single node function to be used in the filter-type actions - // f: Function - // a function to adapt - // o: Object? - // an optional context for f - return function(){ - return this.filter(loopBody(f, arguments, o)); - }; - }; - - var adaptWithCondition = function(f, g, o){ - // summary: - // adapts a single node function to be used in the map-type - // actions, behaves like forEach() or map() depending on arguments - // f: Function - // a function to adapt - // g: Function - // a condition function, if true runs as map(), otherwise runs as forEach() - // o: Object? - // an optional context for f and g - return function(){ - var a = arguments, body = loopBody(f, a, o); - if(g.call(o || dojo.global, a)){ - return this.map(body); // self - } - this.forEach(body); - return this; // self - }; - }; - - var NodeList = function(array){ - // summary: - // Array-like object which adds syntactic - // sugar for chaining, common iteration operations, animation, and - // node manipulation. NodeLists are most often returned as the - // result of dojo.query() calls. - // description: - // NodeList instances provide many utilities that reflect - // core Dojo APIs for Array iteration and manipulation, DOM - // manipulation, and event handling. Instead of needing to dig up - // functions in the dojo.* namespace, NodeLists generally make the - // full power of Dojo available for DOM manipulation tasks in a - // simple, chainable way. - // example: - // create a node list from a node - // | new query.NodeList(dojo.byId("foo")); - // example: - // get a NodeList from a CSS query and iterate on it - // | var l = dojo.query(".thinger"); - // | l.forEach(function(node, index, nodeList){ - // | console.log(index, node.innerHTML); - // | }); - // example: - // use native and Dojo-provided array methods to manipulate a - // NodeList without needing to use dojo.* functions explicitly: - // | var l = dojo.query(".thinger"); - // | // since NodeLists are real arrays, they have a length - // | // property that is both readable and writable and - // | // push/pop/shift/unshift methods - // | console.log(l.length); - // | l.push(dojo.create("span")); - // | - // | // dojo's normalized array methods work too: - // | console.log( l.indexOf(dojo.byId("foo")) ); - // | // ...including the special "function as string" shorthand - // | console.log( l.every("item.nodeType == 1") ); - // | - // | // NodeLists can be [..] indexed, or you can use the at() - // | // function to get specific items wrapped in a new NodeList: - // | var node = l[3]; // the 4th element - // | var newList = l.at(1, 3); // the 2nd and 4th elements - // example: - // the style functions you expect are all there too: - // | // style() as a getter... - // | var borders = dojo.query(".thinger").style("border"); - // | // ...and as a setter: - // | dojo.query(".thinger").style("border", "1px solid black"); - // | // class manipulation - // | dojo.query("li:nth-child(even)").addClass("even"); - // | // even getting the coordinates of all the items - // | var coords = dojo.query(".thinger").coords(); - // example: - // DOM manipulation functions from the dojo.* namespace area also available: - // | // remove all of the elements in the list from their - // | // parents (akin to "deleting" them from the document) - // | dojo.query(".thinger").orphan(); - // | // place all elements in the list at the front of #foo - // | dojo.query(".thinger").place("foo", "first"); - // example: - // Event handling couldn't be easier. `dojo.connect` is mapped in, - // and shortcut handlers are provided for most DOM events: - // | // like dojo.connect(), but with implicit scope - // | dojo.query("li").connect("onclick", console, "log"); - // | - // | // many common event handlers are already available directly: - // | dojo.query("li").onclick(console, "log"); - // | var toggleHovered = dojo.hitch(dojo, "toggleClass", "hovered"); - // | dojo.query("p") - // | .onmouseenter(toggleHovered) - // | .onmouseleave(toggleHovered); - // example: - // chainability is a key advantage of NodeLists: - // | dojo.query(".thinger") - // | .onclick(function(e){ /* ... */ }) - // | .at(1, 3, 8) // get a subset - // | .style("padding", "5px") - // | .forEach(console.log); - var isNew = this instanceof nl && has("array-extensible"); - if(typeof array == "number"){ - array = Array(array); - } - var nodeArray = (array && "length" in array) ? array : arguments; - if(isNew || !nodeArray.sort){ - // make sure it's a real array before we pass it on to be wrapped - var target = isNew ? this : [], - l = target.length = nodeArray.length; - for(var i = 0; i < l; i++){ - target[i] = nodeArray[i]; - } - if(isNew){ - // called with new operator, this means we are going to use this instance and push - // the nodes on to it. This is usually much faster since the NodeList properties - // don't need to be copied (unless the list of nodes is extremely large). - return target; - } - nodeArray = target; - } - // called without new operator, use a real array and copy prototype properties, - // this is slower and exists for back-compat. Should be removed in 2.0. - lang._mixin(nodeArray, nlp); - nodeArray._NodeListCtor = function(array){ - // call without new operator to preserve back-compat behavior - return nl(array); - }; - return nodeArray; - }; - - var nl = NodeList, nlp = nl.prototype = - has("array-extensible") ? [] : {};// extend an array if it is extensible - - // expose adapters and the wrapper as private functions - - nl._wrap = nlp._wrap = tnl; - nl._adaptAsMap = adaptAsMap; - nl._adaptAsForEach = adaptAsForEach; - nl._adaptAsFilter = adaptAsFilter; - nl._adaptWithCondition = adaptWithCondition; - - // mass assignment - - // add array redirectors - forEach(["slice", "splice"], function(name){ - var f = ap[name]; - //Use a copy of the this array via this.slice() to allow .end() to work right in the splice case. - // CANNOT apply ._stash()/end() to splice since it currently modifies - // the existing this array -- it would break backward compatibility if we copy the array before - // the splice so that we can use .end(). So only doing the stash option to this._wrap for slice. - nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); }; - }); - // concat should be here but some browsers with native NodeList have problems with it - - // add array.js redirectors - forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){ - var f = array[name]; - nlp[name] = function(){ return f.apply(dojo, [this].concat(aps.call(arguments, 0))); }; - }); - - lang.extend(NodeList, { - // copy the constructors - constructor: nl, - _NodeListCtor: nl, - toString: function(){ - // Array.prototype.toString can't be applied to objects, so we use join - return this.join(","); - }, - _stash: function(parent){ - // summary: - // private function to hold to a parent NodeList. end() to return the parent NodeList. - // - // example: - // How to make a `dojo/NodeList` method that only returns the third node in - // the dojo/NodeList but allows access to the original NodeList by using this._stash: - // | dojo.extend(NodeList, { - // | third: function(){ - // | var newNodeList = NodeList(this[2]); - // | return newNodeList._stash(this); - // | } - // | }); - // | // then see how _stash applies a sub-list, to be .end()'ed out of - // | dojo.query(".foo") - // | .third() - // | .addClass("thirdFoo") - // | .end() - // | // access to the orig .foo list - // | .removeClass("foo") - // | - // - this._parent = parent; - return this; // dojo/NodeList - }, - - on: function(eventName, listener){ - // summary: - // Listen for events on the nodes in the NodeList. Basic usage is: - // | query(".my-class").on("click", listener); - // This supports event delegation by using selectors as the first argument with the event names as - // pseudo selectors. For example: - // | dojo.query("#my-list").on("li:click", listener); - // This will listen for click events within `<li>` elements that are inside the `#my-list` element. - // Because on supports CSS selector syntax, we can use comma-delimited events as well: - // | dojo.query("#my-list").on("li button:mouseover, li:click", listener); - var handles = this.map(function(node){ - return on(node, eventName, listener); // TODO: apply to the NodeList so the same selector engine is used for matches - }); - handles.remove = function(){ - for(var i = 0; i < handles.length; i++){ - handles[i].remove(); - } - }; - return handles; - }, - - end: function(){ - // summary: - // Ends use of the current `NodeList` by returning the previous NodeList - // that generated the current NodeList. - // description: - // Returns the `NodeList` that generated the current `NodeList`. If there - // is no parent NodeList, an empty NodeList is returned. - // example: - // | dojo.query("a") - // | .filter(".disabled") - // | // operate on the anchors that only have a disabled class - // | .style("color", "grey") - // | .end() - // | // jump back to the list of anchors - // | .style(...) - // - if(this._parent){ - return this._parent; - }else{ - //Just return empty list. - return new this._NodeListCtor(0); - } - }, - - // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods - - // FIXME: handle return values for #3244 - // http://trac.dojotoolkit.org/ticket/3244 - - // FIXME: - // need to wrap or implement: - // join (perhaps w/ innerHTML/outerHTML overload for toString() of items?) - // reduce - // reduceRight - - /*===== - slice: function(begin, end){ - // summary: - // Returns a new NodeList, maintaining this one in place - // description: - // This method behaves exactly like the Array.slice method - // with the caveat that it returns a dojo/NodeList and not a - // raw Array. For more details, see Mozilla's [slice - // documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/slice) - // begin: Integer - // Can be a positive or negative integer, with positive - // integers noting the offset to begin at, and negative - // integers denoting an offset from the end (i.e., to the left - // of the end) - // end: Integer? - // Optional parameter to describe what position relative to - // the NodeList's zero index to end the slice at. Like begin, - // can be positive or negative. - return this._wrap(a.slice.apply(this, arguments)); - }, - - splice: function(index, howmany, item){ - // summary: - // Returns a new NodeList, manipulating this NodeList based on - // the arguments passed, potentially splicing in new elements - // at an offset, optionally deleting elements - // description: - // This method behaves exactly like the Array.splice method - // with the caveat that it returns a dojo/NodeList and not a - // raw Array. For more details, see Mozilla's [splice - // documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice) - // For backwards compatibility, calling .end() on the spliced NodeList - // does not return the original NodeList -- splice alters the NodeList in place. - // index: Integer - // begin can be a positive or negative integer, with positive - // integers noting the offset to begin at, and negative - // integers denoting an offset from the end (i.e., to the left - // of the end) - // howmany: Integer? - // Optional parameter to describe what position relative to - // the NodeList's zero index to end the slice at. Like begin, - // can be positive or negative. - // item: Object...? - // Any number of optional parameters may be passed in to be - // spliced into the NodeList - return this._wrap(a.splice.apply(this, arguments)); // dojo/NodeList - }, - - indexOf: function(value, fromIndex){ - // summary: - // see dojo.indexOf(). The primary difference is that the acted-on - // array is implicitly this NodeList - // value: Object - // The value to search for. - // fromIndex: Integer? - // The location to start searching from. Optional. Defaults to 0. - // description: - // For more details on the behavior of indexOf, see Mozilla's - // [indexOf - // docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf) - // returns: - // Positive Integer or 0 for a match, -1 of not found. - return d.indexOf(this, value, fromIndex); // Integer - }, - - lastIndexOf: function(value, fromIndex){ - // summary: - // see dojo.lastIndexOf(). The primary difference is that the - // acted-on array is implicitly this NodeList - // description: - // For more details on the behavior of lastIndexOf, see - // Mozilla's [lastIndexOf - // docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf) - // value: Object - // The value to search for. - // fromIndex: Integer? - // The location to start searching from. Optional. Defaults to 0. - // returns: - // Positive Integer or 0 for a match, -1 of not found. - return d.lastIndexOf(this, value, fromIndex); // Integer - }, - - every: function(callback, thisObject){ - // summary: - // see `dojo.every()` and the [Array.every - // docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every). - // Takes the same structure of arguments and returns as - // dojo.every() with the caveat that the passed array is - // implicitly this NodeList - // callback: Function - // the callback - // thisObject: Object? - // the context - return d.every(this, callback, thisObject); // Boolean - }, - - some: function(callback, thisObject){ - // summary: - // Takes the same structure of arguments and returns as - // `dojo.some()` with the caveat that the passed array is - // implicitly this NodeList. See `dojo.some()` and Mozilla's - // [Array.some - // documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some). - // callback: Function - // the callback - // thisObject: Object? - // the context - return d.some(this, callback, thisObject); // Boolean - }, - =====*/ - - concat: function(item){ - // summary: - // Returns a new NodeList comprised of items in this NodeList - // as well as items passed in as parameters - // description: - // This method behaves exactly like the Array.concat method - // with the caveat that it returns a `NodeList` and not a - // raw Array. For more details, see the [Array.concat - // docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/concat) - // item: Object? - // Any number of optional parameters may be passed in to be - // spliced into the NodeList - - //return this._wrap(apc.apply(this, arguments)); - // the line above won't work for the native NodeList, or for Dojo NodeLists either :-( - - // implementation notes: - // Array.concat() doesn't recognize native NodeLists or Dojo NodeLists - // as arrays, and so does not inline them into a unioned array, but - // appends them as single entities. Both the original NodeList and the - // items passed in as parameters must be converted to raw Arrays - // and then the concatenation result may be re-_wrap()ed as a Dojo NodeList. - - var t = aps.call(this, 0), - m = array.map(arguments, function(a){ - return aps.call(a, 0); - }); - return this._wrap(apc.apply(t, m), this); // dojo/NodeList - }, - - map: function(/*Function*/ func, /*Function?*/ obj){ - // summary: - // see dojo.map(). The primary difference is that the acted-on - // array is implicitly this NodeList and the return is a - // NodeList (a subclass of Array) - return this._wrap(array.map(this, func, obj), this); // dojo/NodeList - }, - - forEach: function(callback, thisObj){ - // summary: - // see `dojo.forEach()`. The primary difference is that the acted-on - // array is implicitly this NodeList. If you want the option to break out - // of the forEach loop, use every() or some() instead. - forEach(this, callback, thisObj); - // non-standard return to allow easier chaining - return this; // dojo/NodeList - }, - filter: function(/*String|Function*/ filter){ - // summary: - // "masks" the built-in javascript filter() method (supported - // in Dojo via `dojo.filter`) to support passing a simple - // string filter in addition to supporting filtering function - // objects. - // filter: - // If a string, a CSS rule like ".thinger" or "div > span". - // example: - // "regular" JS filter syntax as exposed in dojo.filter: - // | dojo.query("*").filter(function(item){ - // | // highlight every paragraph - // | return (item.nodeName == "p"); - // | }).style("backgroundColor", "yellow"); - // example: - // the same filtering using a CSS selector - // | dojo.query("*").filter("p").styles("backgroundColor", "yellow"); - - var a = arguments, items = this, start = 0; - if(typeof filter == "string"){ // inline'd type check - items = query._filterResult(this, a[0]); - if(a.length == 1){ - // if we only got a string query, pass back the filtered results - return items._stash(this); // dojo/NodeList - } - // if we got a callback, run it over the filtered items - start = 1; - } - return this._wrap(array.filter(items, a[start], a[start + 1]), this); // dojo/NodeList - }, - instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){ - // summary: - // Create a new instance of a specified class, using the - // specified properties and each node in the NodeList as a - // srcNodeRef. - // example: - // Grabs all buttons in the page and converts them to dijit/form/Button's. - // | var buttons = query("button").instantiate(Button, {showLabel: true}); - var c = lang.isFunction(declaredClass) ? declaredClass : lang.getObject(declaredClass); - properties = properties || {}; - return this.forEach(function(node){ - new c(properties, node); - }); // dojo/NodeList - }, - at: function(/*===== index =====*/){ - // summary: - // Returns a new NodeList comprised of items in this NodeList - // at the given index or indices. - // - // index: Integer... - // One or more 0-based indices of items in the current - // NodeList. A negative index will start at the end of the - // list and go backwards. - // - // example: - // Shorten the list to the first, second, and third elements - // | query("a").at(0, 1, 2).forEach(fn); - // - // example: - // Retrieve the first and last elements of a unordered list: - // | query("ul > li").at(0, -1).forEach(cb); - // - // example: - // Do something for the first element only, but end() out back to - // the original list and continue chaining: - // | query("a").at(0).onclick(fn).end().forEach(function(n){ - // | console.log(n); // all anchors on the page. - // | }) - - var t = new this._NodeListCtor(0); - forEach(arguments, function(i){ - if(i < 0){ i = this.length + i; } - if(this[i]){ t.push(this[i]); } - }, this); - return t._stash(this); // dojo/NodeList - } - }); - - function queryForEngine(engine, NodeList){ - var query = function(/*String*/ query, /*String|DOMNode?*/ root){ - // summary: - // Returns nodes which match the given CSS selector, searching the - // entire document by default but optionally taking a node to scope - // the search by. Returns an instance of NodeList. - if(typeof root == "string"){ - root = dom.byId(root); - if(!root){ - return new NodeList([]); - } - } - var results = typeof query == "string" ? engine(query, root) : query ? query.orphan ? query : [query] : []; - if(results.orphan){ - // already wrapped - return results; - } - return new NodeList(results); - }; - query.matches = engine.match || function(node, selector, root){ - // summary: - // Test to see if a node matches a selector - return query.filter([node], selector, root).length > 0; - }; - // the engine provides a filtering function, use it to for matching - query.filter = engine.filter || function(nodes, selector, root){ - // summary: - // Filters an array of nodes. Note that this does not guarantee to return a NodeList, just an array. - return query(selector, root).filter(function(node){ - return array.indexOf(nodes, node) > -1; - }); - }; - if(typeof engine != "function"){ - var search = engine.search; - engine = function(selector, root){ - // Slick does it backwards (or everyone else does it backwards, probably the latter) - return search(root || document, selector); - }; - } - return query; - } - var query = queryForEngine(defaultEngine, NodeList); - /*===== - query = function(selector, context){ - // summary: - // This modules provides DOM querying functionality. The module export is a function - // that can be used to query for DOM nodes by CSS selector and returns a NodeList - // representing the matching nodes. - // selector: String - // A CSS selector to search for. - // context: String|DomNode? - // An optional context to limit the searching scope. Only nodes under `context` will be - // scanned. - // example: - // add an onclick handler to every submit button in the document - // which causes the form to be sent via Ajax instead: - // | require(["dojo/query"], function(query){ - // | query("input[type='submit']").on("click", function(e){ - // | dojo.stopEvent(e); // prevent sending the form - // | var btn = e.target; - // | dojo.xhrPost({ - // | form: btn.form, - // | load: function(data){ - // | // replace the form with the response - // | var div = dojo.doc.createElement("div"); - // | dojo.place(div, btn.form, "after"); - // | div.innerHTML = data; - // | dojo.style(btn.form, "display", "none"); - // | } - // | }); - // | }); - // | }); - // - // description: - // dojo/query is responsible for loading the appropriate query engine and wrapping - // its results with a `NodeList`. You can use dojo/query with a specific selector engine - // by using it as a plugin. For example, if you installed the sizzle package, you could - // use it as the selector engine with: - // | require(["dojo/query!sizzle"], function(query){ - // | query("div")... - // - // The id after the ! can be a module id of the selector engine or one of the following values: - // - // - acme: This is the default engine used by Dojo base, and will ensure that the full - // Acme engine is always loaded. - // - // - css2: If the browser has a native selector engine, this will be used, otherwise a - // very minimal lightweight selector engine will be loaded that can do simple CSS2 selectors - // (by #id, .class, tag, and [name=value] attributes, with standard child or descendant (>) - // operators) and nothing more. - // - // - css2.1: If the browser has a native selector engine, this will be used, otherwise the - // full Acme engine will be loaded. - // - // - css3: If the browser has a native selector engine with support for CSS3 pseudo - // selectors (most modern browsers except IE8), this will be used, otherwise the - // full Acme engine will be loaded. - // - // - Or the module id of a selector engine can be used to explicitly choose the selector engine - // - // For example, if you are using CSS3 pseudo selectors in module, you can specify that - // you will need support them with: - // | require(["dojo/query!css3"], function(query){ - // | query('#t > h3:nth-child(odd)')... - // - // You can also choose the selector engine/load configuration by setting the query-selector: - // For example: - // | <script data-dojo-config="query-selector:'css3'" src="dojo.js"></script> - // - return new NodeList(); // dojo/NodeList - }; - =====*/ - - // the query that is returned from this module is slightly different than dojo.query, - // because dojo.query has to maintain backwards compatibility with returning a - // true array which has performance problems. The query returned from the module - // does not use true arrays, but rather inherits from Array, making it much faster to - // instantiate. - dojo.query = queryForEngine(defaultEngine, function(array){ - // call it without the new operator to invoke the back-compat behavior that returns a true array - return NodeList(array); // dojo/NodeList - }); - - query.load = function(id, parentRequire, loaded){ - // summary: - // can be used as AMD plugin to conditionally load new query engine - // example: - // | require(["dojo/query!custom"], function(qsa){ - // | // loaded selector/custom.js as engine - // | qsa("#foobar").forEach(...); - // | }); - loader.load(id, parentRequire, function(engine){ - loaded(queryForEngine(engine, NodeList)); - }); - }; - - dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){ - return new NodeList(query.filter(nodes, selector, root)); - }; - dojo.NodeList = query.NodeList = NodeList; - return query; -}); |