mirror of
https://git.tt-rss.org/git/tt-rss.git
synced 2025-12-14 21:35:56 +00:00
dojo: remove uncompressed files
This commit is contained in:
Andrew Dolgov
@@ -1,454 +0,0 @@
|
||||
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:
|
||||
// | <div id="foo">
|
||||
// | <p>
|
||||
// | bacon is tasty, <span>dontcha think?</span>
|
||||
// | </p>
|
||||
// | </div>
|
||||
// | <div id="bar">
|
||||
// | <p>great comedians may not be funny <span>in person</span></p>
|
||||
// | </div>
|
||||
// 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("<h4>NOTE:</h4>", "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: '<b>${id}: </b><span>${name}</span>',
|
||||
// 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: '<button dojoType="dijit.form.Button">${text}</button>',
|
||||
// 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;
|
||||
});
|
||||
Reference in New Issue
Block a user