From 1354d17270961fff662d40f90521223f8fd0d73b Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Tue, 14 Aug 2012 18:59:10 +0400 Subject: update dojo to 1.7.3 --- lib/dojo/NodeList-dom.js.uncompressed.js | 454 +++++++++++++++++++++++++++++++ 1 file changed, 454 insertions(+) create mode 100644 lib/dojo/NodeList-dom.js.uncompressed.js (limited to 'lib/dojo/NodeList-dom.js.uncompressed.js') diff --git a/lib/dojo/NodeList-dom.js.uncompressed.js b/lib/dojo/NodeList-dom.js.uncompressed.js new file mode 100644 index 000000000..2460c79c9 --- /dev/null +++ b/lib/dojo/NodeList-dom.js.uncompressed.js @@ -0,0 +1,454 @@ +define("dojo/NodeList-dom", ["./_base/kernel", "./query", "./_base/array", "./_base/lang", "./dom-class", "./dom-construct", "./dom-geometry", "./dom-attr", "./dom-style"], function(dojo, query, array, lang, domCls, domCtr, domGeom, domAttr, domStyle){ + /*===== var NodeList = dojo.NodeList; =====*/ + var magicGuard = function(a){ + // summary: + // the guard function for dojo.attr() and dojo.style() + return a.length == 1 && (typeof a[0] == "string"); // inline'd type check + }; + + var orphan = function(node){ + // summary: + // function to orphan nodes + var p = node.parentNode; + if(p){ + p.removeChild(node); + } + }; + // FIXME: should we move orphan() to dojo.html? + + var NodeList = query.NodeList, + awc = NodeList._adaptWithCondition, + aafe = NodeList._adaptAsForEach, + aam = NodeList._adaptAsMap; + + function getSet(module){ + return function(node, name, value){ + if(arguments.length == 2){ + return module[typeof name == "string" ? "get" : "set"](node, name); + } + // setter + return module.set(node, name, value); + }; + } + + lang.extend(NodeList, { + _normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){ + // summary: + // normalizes data to an array of items to insert. + // description: + // If content is an object, it can have special properties "template" and + // "parse". If "template" is defined, then the template value is run through + // dojo.string.substitute (if dojo.string.substitute has been dojo.required elsewhere), + // or if templateFunc is a function on the content, that function will be used to + // transform the template into a final string to be used for for passing to dojo._toDom. + // If content.parse is true, then it is remembered for later, for when the content + // nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets + // (if dojo.parser has been dojo.required elsewhere). + + //Wanted to just use a DocumentFragment, but for the array/NodeList + //case that meant using cloneNode, but we may not want that. + //Cloning should only happen if the node operations span + //multiple refNodes. Also, need a real array, not a NodeList from the + //DOM since the node movements could change those NodeLists. + + var parse = content.parse === true; + + //Do we have an object that needs to be run through a template? + if(typeof content.template == "string"){ + var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute); + content = templateFunc ? templateFunc(content.template, content) : content; + } + + var type = (typeof content); + if(type == "string" || type == "number"){ + content = domCtr.toDom(content, (refNode && refNode.ownerDocument)); + if(content.nodeType == 11){ + //DocumentFragment. It cannot handle cloneNode calls, so pull out the children. + content = lang._toArray(content.childNodes); + }else{ + content = [content]; + } + }else if(!lang.isArrayLike(content)){ + content = [content]; + }else if(!lang.isArray(content)){ + //To get to this point, content is array-like, but + //not an array, which likely means a DOM NodeList. Convert it now. + content = lang._toArray(content); + } + + //Pass around the parse info + if(parse){ + content._runParse = true; + } + return content; //Array + }, + + _cloneNode: function(/*DOMNode*/ node){ + // summary: + // private utility to clone a node. Not very interesting in the vanilla + // dojo.NodeList case, but delegates could do interesting things like + // clone event handlers if that is derivable from the node. + return node.cloneNode(true); + }, + + _place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){ + // summary: + // private utility to handle placing an array of nodes relative to another node. + // description: + // Allows for cloning the nodes in the array, and for + // optionally parsing widgets, if ary._runParse is true. + + //Avoid a disallowed operation if trying to do an innerHTML on a non-element node. + if(refNode.nodeType != 1 && position == "only"){ + return; + } + var rNode = refNode, tempNode; + + //Always cycle backwards in case the array is really a + //DOM NodeList and the DOM operations take it out of the live collection. + var length = ary.length; + for(var i = length - 1; i >= 0; i--){ + var node = (useClone ? this._cloneNode(ary[i]) : ary[i]); + + //If need widget parsing, use a temp node, instead of waiting after inserting into + //real DOM because we need to start widget parsing at one node up from current node, + //which could cause some already parsed widgets to be parsed again. + if(ary._runParse && dojo.parser && dojo.parser.parse){ + if(!tempNode){ + tempNode = rNode.ownerDocument.createElement("div"); + } + tempNode.appendChild(node); + dojo.parser.parse(tempNode); + node = tempNode.firstChild; + while(tempNode.firstChild){ + tempNode.removeChild(tempNode.firstChild); + } + } + + if(i == length - 1){ + domCtr.place(node, rNode, position); + }else{ + rNode.parentNode.insertBefore(node, rNode); + } + rNode = node; + } + }, + + /*===== + position: function(){ + // summary: + // Returns border-box objects (x/y/w/h) of all elements in a node list + // as an Array (*not* a NodeList). Acts like `dojo.position`, though + // assumes the node passed is each node in this list. + + return dojo.map(this, dojo.position); // Array + }, + + attr: function(property, value){ + // summary: + // gets or sets the DOM attribute for every element in the + // NodeList. See also `dojo.attr` + // property: String + // the attribute to get/set + // value: String? + // optional. The value to set the property to + // returns: + // if no value is passed, the result is an array of attribute values + // If a value is passed, the return is this NodeList + // example: + // Make all nodes with a particular class focusable: + // | dojo.query(".focusable").attr("tabIndex", -1); + // example: + // Disable a group of buttons: + // | dojo.query("button.group").attr("disabled", true); + // example: + // innerHTML can be assigned or retrieved as well: + // | // get the innerHTML (as an array) for each list item + // | var ih = dojo.query("li.replaceable").attr("innerHTML"); + return; // dojo.NodeList + return; // Array + }, + + style: function(property, value){ + // summary: + // gets or sets the CSS property for every element in the NodeList + // property: String + // the CSS property to get/set, in JavaScript notation + // ("lineHieght" instead of "line-height") + // value: String? + // optional. The value to set the property to + // returns: + // if no value is passed, the result is an array of strings. + // If a value is passed, the return is this NodeList + return; // dojo.NodeList + return; // Array + }, + + addClass: function(className){ + // summary: + // adds the specified class to every node in the list + // className: String|Array + // A String class name to add, or several space-separated class names, + // or an array of class names. + return; // dojo.NodeList + }, + + removeClass: function(className){ + // summary: + // removes the specified class from every node in the list + // className: String|Array? + // An optional String class name to remove, or several space-separated + // class names, or an array of class names. If omitted, all class names + // will be deleted. + // returns: + // dojo.NodeList, this list + return; // dojo.NodeList + }, + + toggleClass: function(className, condition){ + // summary: + // Adds a class to node if not present, or removes if present. + // Pass a boolean condition if you want to explicitly add or remove. + // condition: Boolean? + // If passed, true means to add the class, false means to remove. + // className: String + // the CSS class to add + return; // dojo.NodeList + }, + + empty: function(){ + // summary: + // clears all content from each node in the list. Effectively + // equivalent to removing all child nodes from every item in + // the list. + return this.forEach("item.innerHTML='';"); // dojo.NodeList + // FIXME: should we be checking for and/or disposing of widgets below these nodes? + }, + =====*/ + + // useful html methods + attr: awc(getSet(domAttr), magicGuard), + style: awc(getSet(domStyle), magicGuard), + + addClass: aafe(domCls.add), + removeClass: aafe(domCls.remove), + replaceClass: aafe(domCls.replace), + toggleClass: aafe(domCls.toggle), + + empty: aafe(domCtr.empty), + removeAttr: aafe(domAttr.remove), + + position: aam(domGeom.position), + marginBox: aam(domGeom.getMarginBox), + + // FIXME: connectPublisher()? connectRunOnce()? + + /* + destroy: function(){ + // summary: + // destroys every item in the list. + this.forEach(d.destroy); + // FIXME: should we be checking for and/or disposing of widgets below these nodes? + }, + */ + + place: function(/*String||Node*/ queryOrNode, /*String*/ position){ + // summary: + // places elements of this node list relative to the first element matched + // by queryOrNode. Returns the original NodeList. See: `dojo.place` + // queryOrNode: + // may be a string representing any valid CSS3 selector or a DOM node. + // In the selector case, only the first matching element will be used + // for relative positioning. + // position: + // can be one of: + // | "last" (default) + // | "first" + // | "before" + // | "after" + // | "only" + // | "replace" + // or an offset in the childNodes property + var item = query(queryOrNode)[0]; + return this.forEach(function(node){ domCtr.place(node, item, position); }); // dojo.NodeList + }, + + orphan: function(/*String?*/ filter){ + // summary: + // removes elements in this list that match the filter + // from their parents and returns them as a new NodeList. + // filter: + // CSS selector like ".foo" or "div > span" + // returns: + // `dojo.NodeList` containing the orphaned elements + return (filter ? query._filterResult(this, filter) : this).forEach(orphan); // dojo.NodeList + }, + + adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){ + // summary: + // places any/all elements in queryOrListOrNode at a + // position relative to the first element in this list. + // Returns a dojo.NodeList of the adopted elements. + // queryOrListOrNode: + // a DOM node or a query string or a query result. + // Represents the nodes to be adopted relative to the + // first element of this NodeList. + // position: + // can be one of: + // | "last" (default) + // | "first" + // | "before" + // | "after" + // | "only" + // | "replace" + // or an offset in the childNodes property + return query(queryOrListOrNode).place(this[0], position)._stash(this); // dojo.NodeList + }, + + // FIXME: do we need this? + query: function(/*String*/ queryStr){ + // summary: + // Returns a new list whose members match the passed query, + // assuming elements of the current NodeList as the root for + // each search. + // example: + // assume a DOM created by this markup: + // |
+ // |

+ // | bacon is tasty, dontcha think? + // |

+ // |
+ // |
+ // |

great comedians may not be funny in person

+ // |
+ // If we are presented with the following definition for a NodeList: + // | var l = new dojo.NodeList(dojo.byId("foo"), dojo.byId("bar")); + // it's possible to find all span elements under paragraphs + // contained by these elements with this sub-query: + // | var spans = l.query("p span"); + + // FIXME: probably slow + if(!queryStr){ return this; } + var ret = new NodeList; + this.map(function(node){ + // FIXME: why would we ever get undefined here? + query(queryStr, node).forEach(function(subNode){ + if(subNode !== undefined){ + ret.push(subNode); + } + }); + }); + return ret._stash(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 + }, + + /* + // FIXME: should this be "copyTo" and include parenting info? + clone: function(){ + // summary: + // creates node clones of each element of this list + // and returns a new list containing the clones + }, + */ + + addContent: function(/*String||DomNode||Object||dojo.NodeList*/ content, /*String||Integer?*/ position){ + // summary: + // add a node, NodeList or some HTML as a string to every item in the + // list. Returns the original list. + // description: + // a copy of the HTML content is added to each item in the + // list, with an optional position argument. If no position + // argument is provided, the content is appended to the end of + // each item. + // content: + // DOM node, HTML in string format, a NodeList or an Object. If a DOM node or + // NodeList, the content will be cloned if the current NodeList has more than one + // element. Only the DOM nodes are cloned, no event handlers. If it is an Object, + // it should be an object with at "template" String property that has the HTML string + // to insert. If dojo.string has already been dojo.required, then dojo.string.substitute + // will be used on the "template" to generate the final HTML string. Other allowed + // properties on the object are: "parse" if the HTML + // string should be parsed for widgets (dojo.require("dojo.parser") to get that + // option to work), and "templateFunc" if a template function besides dojo.string.substitute + // should be used to transform the "template". + // position: + // can be one of: + // | "last"||"end" (default) + // | "first||"start" + // | "before" + // | "after" + // | "replace" (replaces nodes in this NodeList with new content) + // | "only" (removes other children of the nodes so new content is the only child) + // or an offset in the childNodes property + // example: + // appends content to the end if the position is omitted + // | dojo.query("h3 > p").addContent("hey there!"); + // example: + // add something to the front of each element that has a + // "thinger" property: + // | dojo.query("[thinger]").addContent("...", "first"); + // example: + // adds a header before each element of the list + // | dojo.query(".note").addContent("

NOTE:

", "before"); + // example: + // add a clone of a DOM node to the end of every element in + // the list, removing it from its existing parent. + // | dojo.query(".note").addContent(dojo.byId("foo")); + // example: + // Append nodes from a templatized string. + // dojo.require("dojo.string"); + // dojo.query(".note").addContent({ + // template: '${id}: ${name}', + // id: "user332", + // name: "Mr. Anderson" + // }); + // example: + // Append nodes from a templatized string that also has widgets parsed. + // dojo.require("dojo.string"); + // dojo.require("dojo.parser"); + // var notes = dojo.query(".note").addContent({ + // template: '', + // parse: true, + // text: "Send" + // }); + content = this._normalize(content, this[0]); + for(var i = 0, node; (node = this[i]); i++){ + this._place(content, node, position, i > 0); + } + return this; //dojo.NodeList + } + }); + + /*===== return dojo.NodeList; =====*/ + return NodeList; +}); -- cgit v1.2.3