public/tt-rss
1
0
Fork 0
mirror of https://git.tt-rss.org/git/tt-rss.git synced 2025-12-15 20:55:56 +00:00
Code Issues Releases Wiki Activity

dojo: remove uncompressed files

Browse Source
This commit is contained in:
Andrew Dolgov
2012-08-14 19:04:32 +04:00
parent 973c4a649f
commit 0181c01109
724 changed files with 0 additions and 137570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

376
lib/dojo/io/iframe.js.uncompressed.js
View File

@@ -1,376 +0,0 @@
define("dojo/io/iframe", ["../main", "require"], function(dojo, require) {
// module:
// dojo/io/iframe
// summary:
// TODOC
dojo.getObject("io", true, dojo);
/*=====
dojo.declare("dojo.io.iframe.__ioArgs", dojo.__IoArgs, {
constructor: function(){
// summary:
// All the properties described in the dojo.__ioArgs type, apply
// to this type. The following additional properties are allowed
// for dojo.io.iframe.send():
// method: String?
// The HTTP method to use. "GET" or "POST" are the only supported
// values. It will try to read the value from the form node's
// method, then try this argument. If neither one exists, then it
// defaults to POST.
// handleAs: String?
// Specifies what format the result data should be given to the
// load/handle callback. Valid values are: text, html, xml, json,
// javascript. IMPORTANT: For all values EXCEPT html and xml, The
// server response should be an HTML file with a textarea element.
// The response data should be inside the textarea element. Using an
// HTML document the only reliable, cross-browser way this
// transport can know when the response has loaded. For the html
// handleAs value, just return a normal HTML document. NOTE: xml
// is now supported with this transport (as of 1.1+); a known issue
// is if the XML document in question is malformed, Internet Explorer
// will throw an uncatchable error.
// content: Object?
// If "form" is one of the other args properties, then the content
// object properties become hidden form form elements. For
// instance, a content object of {name1 : "value1"} is converted
// to a hidden form element with a name of "name1" and a value of
// "value1". If there is not a "form" property, then the content
// object is converted into a name=value&name=value string, by
// using dojo.objectToQuery().
this.method = method;
this.handleAs = handleAs;
this.content = content;
}
});
=====*/
dojo.io.iframe = {
// summary:
// Sends an Ajax I/O call using and Iframe (for instance, to upload files)
create: function(/*String*/fname, /*String*/onloadstr, /*String?*/uri){
// summary:
// Creates a hidden iframe in the page. Used mostly for IO
// transports. You do not need to call this to start a
// dojo.io.iframe request. Just call send().
// fname: String
// The name of the iframe. Used for the name attribute on the
// iframe.
// onloadstr: String
// A string of JavaScript that will be executed when the content
// in the iframe loads.
// uri: String
// The value of the src attribute on the iframe element. If a
// value is not given, then dojo/resources/blank.html will be
// used.
if(window[fname]){ return window[fname]; }
if(window.frames[fname]){ return window.frames[fname]; }
var turi = uri;
if(!turi){
if(dojo.config["useXDomain"] && !dojo.config["dojoBlankHtmlUrl"]){
console.warn("dojo.io.iframe.create: When using cross-domain Dojo builds,"
+ " please save dojo/resources/blank.html to your domain and set djConfig.dojoBlankHtmlUrl"
+ " to the path on your domain to blank.html");
}
turi = (dojo.config["dojoBlankHtmlUrl"]||require.toUrl("../resources/blank.html"));
}
var cframe = dojo.place(
'<iframe id="'+fname+'" name="'+fname+'" src="'+turi+'" onload="'+onloadstr+
'" style="position: absolute; left: 1px; top: 1px; height: 1px; width: 1px; visibility: hidden">',
dojo.body());
window[fname] = cframe;
return cframe;
},
setSrc: function(/*DOMNode*/iframe, /*String*/src, /*Boolean*/replace){
//summary:
// Sets the URL that is loaded in an IFrame. The replace parameter
// indicates whether location.replace() should be used when
// changing the location of the iframe.
try{
if(!replace){
if(dojo.isWebKit){
iframe.location = src;
}else{
frames[iframe.name].location = src;
}
}else{
// Fun with DOM 0 incompatibilities!
var idoc;
if(dojo.isIE || dojo.isWebKit){
idoc = iframe.contentWindow.document;
}else{ // if(d.isMozilla){
idoc = iframe.contentWindow;
}
//For Safari (at least 2.0.3) and Opera, if the iframe
//has just been created but it doesn't have content
//yet, then iframe.document may be null. In that case,
//use iframe.location and return.
if(!idoc){
iframe.location = src;
}else{
idoc.location.replace(src);
}
}
}catch(e){
console.log("dojo.io.iframe.setSrc: ", e);
}
},
doc: function(/*DOMNode*/iframeNode){
//summary: Returns the document object associated with the iframe DOM Node argument.
return iframeNode.contentDocument || // W3
(
(
(iframeNode.name) && (iframeNode.document) &&
(dojo.doc.getElementsByTagName("iframe")[iframeNode.name].contentWindow) &&
(dojo.doc.getElementsByTagName("iframe")[iframeNode.name].contentWindow.document)
)
) || // IE
(
(iframeNode.name)&&(dojo.doc.frames[iframeNode.name])&&
(dojo.doc.frames[iframeNode.name].document)
) || null;
},
send: function(/*dojo.io.iframe.__ioArgs*/args){
//summary:
// Function that sends the request to the server.
// This transport can only process one send() request at a time, so if send() is called
//multiple times, it will queue up the calls and only process one at a time.
if(!this["_frame"]){
this._frame = this.create(this._iframeName, dojo._scopeName + ".io.iframe._iframeOnload();");
}
//Set up the deferred.
var dfd = dojo._ioSetArgs(
args,
function(/*Deferred*/dfd){
//summary: canceller function for dojo._ioSetArgs call.
dfd.canceled = true;
dfd.ioArgs._callNext();
},
function(/*Deferred*/dfd){
//summary: okHandler function for dojo._ioSetArgs call.
var value = null;
try{
var ioArgs = dfd.ioArgs;
var dii = dojo.io.iframe;
var ifd = dii.doc(dii._frame);
var handleAs = ioArgs.handleAs;
//Assign correct value based on handleAs value.
value = ifd; //html
if(handleAs != "html"){
if(handleAs == "xml"){
// FF, Saf 3+ and Opera all seem to be fine with ifd being xml. We have to
// do it manually for IE6-8. Refs #6334.
if(dojo.isIE < 9 || (dojo.isIE && dojo.isQuirks)){
dojo.query("a", dii._frame.contentWindow.document.documentElement).orphan();
var xmlText=(dii._frame.contentWindow.document).documentElement.innerText;
xmlText=xmlText.replace(/>\s+</g, "><");
xmlText=dojo.trim(xmlText);
//Reusing some code in base dojo for handling XML content. Simpler and keeps
//Core from duplicating the effort needed to locate the XML Parser on IE.
var fauxXhr = { responseText: xmlText };
value = dojo._contentHandlers["xml"](fauxXhr); // DOMDocument
}
}else{
value = ifd.getElementsByTagName("textarea")[0].value; //text
if(handleAs == "json"){
value = dojo.fromJson(value); //json
}else if(handleAs == "javascript"){
value = dojo.eval(value); //javascript
}
}
}
}catch(e){
value = e;
}finally{
ioArgs._callNext();
}
return value;
},
function(/*Error*/error, /*Deferred*/dfd){
//summary: errHandler function for dojo._ioSetArgs call.
dfd.ioArgs._hasError = true;
dfd.ioArgs._callNext();
return error;
}
);
//Set up a function that will fire the next iframe request. Make sure it only
//happens once per deferred.
dfd.ioArgs._callNext = function(){
if(!this["_calledNext"]){
this._calledNext = true;
dojo.io.iframe._currentDfd = null;
dojo.io.iframe._fireNextRequest();
}
};
this._dfdQueue.push(dfd);
this._fireNextRequest();
//Add it the IO watch queue, to get things like timeout support.
dojo._ioWatch(
dfd,
function(/*Deferred*/dfd){
//validCheck
return !dfd.ioArgs["_hasError"];
},
function(dfd){
//ioCheck
return (!!dfd.ioArgs["_finished"]);
},
function(dfd){
//resHandle
if(dfd.ioArgs._finished){
dfd.callback(dfd);
}else{
dfd.errback(new Error("Invalid dojo.io.iframe request state"));
}
}
);
return dfd;
},
_currentDfd: null,
_dfdQueue: [],
_iframeName: dojo._scopeName + "IoIframe",
_fireNextRequest: function(){
//summary: Internal method used to fire the next request in the bind queue.
try{
if((this._currentDfd)||(this._dfdQueue.length == 0)){ return; }
//Find next deferred, skip the canceled ones.
do{
var dfd = this._currentDfd = this._dfdQueue.shift();
} while(dfd && dfd.canceled && this._dfdQueue.length);
//If no more dfds, cancel.
if(!dfd || dfd.canceled){
this._currentDfd = null;
return;
}
var ioArgs = dfd.ioArgs;
var args = ioArgs.args;
ioArgs._contentToClean = [];
var fn = dojo.byId(args["form"]);
var content = args["content"] || {};
if(fn){
if(content){
// if we have things in content, we need to add them to the form
// before submission
var pHandler = function(name, value) {
dojo.create("input", {type: "hidden", name: name, value: value}, fn);
ioArgs._contentToClean.push(name);
};
for(var x in content){
var val = content[x];
if(dojo.isArray(val) && val.length > 1){
var i;
for (i = 0; i < val.length; i++) {
pHandler(x,val[i]);
}
}else{
if(!fn[x]){
pHandler(x,val);
}else{
fn[x].value = val;
}
}
}
}
//IE requires going through getAttributeNode instead of just getAttribute in some form cases,
//so use it for all. See #2844
var actnNode = fn.getAttributeNode("action");
var mthdNode = fn.getAttributeNode("method");
var trgtNode = fn.getAttributeNode("target");
if(args["url"]){
ioArgs._originalAction = actnNode ? actnNode.value : null;
if(actnNode){
actnNode.value = args.url;
}else{
fn.setAttribute("action",args.url);
}
}
if(!mthdNode || !mthdNode.value){
if(mthdNode){
mthdNode.value= (args["method"]) ? args["method"] : "post";
}else{
fn.setAttribute("method", (args["method"]) ? args["method"] : "post");
}
}
ioArgs._originalTarget = trgtNode ? trgtNode.value: null;
if(trgtNode){
trgtNode.value = this._iframeName;
}else{
fn.setAttribute("target", this._iframeName);
}
fn.target = this._iframeName;
dojo._ioNotifyStart(dfd);
fn.submit();
}else{
// otherwise we post a GET string by changing URL location for the
// iframe
var tmpUrl = args.url + (args.url.indexOf("?") > -1 ? "&" : "?") + ioArgs.query;
dojo._ioNotifyStart(dfd);
this.setSrc(this._frame, tmpUrl, true);
}
}catch(e){
dfd.errback(e);
}
},
_iframeOnload: function(){
var dfd = this._currentDfd;
if(!dfd){
this._fireNextRequest();
return;
}
var ioArgs = dfd.ioArgs;
var args = ioArgs.args;
var fNode = dojo.byId(args.form);
if(fNode){
// remove all the hidden content inputs
var toClean = ioArgs._contentToClean;
for(var i = 0; i < toClean.length; i++) {
var key = toClean[i];
//Need to cycle over all nodes since we may have added
//an array value which means that more than one node could
//have the same .name value.
for(var j = 0; j < fNode.childNodes.length; j++){
var chNode = fNode.childNodes[j];
if(chNode.name == key){
dojo.destroy(chNode);
break;
}
}
}
// restore original action + target
if(ioArgs["_originalAction"]){
fNode.setAttribute("action", ioArgs._originalAction);
}
if(ioArgs["_originalTarget"]){
fNode.setAttribute("target", ioArgs._originalTarget);
fNode.target = ioArgs._originalTarget;
}
}
ioArgs._finished = true;
}
};
return dojo.io.iframe;
});

256
lib/dojo/io/script.js.uncompressed.js
View File

@@ -1,256 +0,0 @@
define("dojo/io/script", ["../main"], function(dojo) {
// module:
// dojo/io/script
// summary:
// TODOC
dojo.getObject("io", true, dojo);
/*=====
dojo.declare("dojo.io.script.__ioArgs", dojo.__IoArgs, {
constructor: function(){
// summary:
// All the properties described in the dojo.__ioArgs type, apply to this
// type as well, EXCEPT "handleAs". It is not applicable to
// dojo.io.script.get() calls, since it is implied by the usage of
// "jsonp" (response will be a JSONP call returning JSON)
// or the response is pure JavaScript defined in
// the body of the script that was attached.
// callbackParamName: String
// Deprecated as of Dojo 1.4 in favor of "jsonp", but still supported for
// legacy code. See notes for jsonp property.
// jsonp: String
// The URL parameter name that indicates the JSONP callback string.
// For instance, when using Yahoo JSONP calls it is normally,
// jsonp: "callback". For AOL JSONP calls it is normally
// jsonp: "c".
// checkString: String
// A string of JavaScript that when evaluated like so:
// "typeof(" + checkString + ") != 'undefined'"
// being true means that the script fetched has been loaded.
// Do not use this if doing a JSONP type of call (use callbackParamName instead).
// frameDoc: Document
// The Document object for a child iframe. If this is passed in, the script
// will be attached to that document. This can be helpful in some comet long-polling
// scenarios with Firefox and Opera.
this.callbackParamName = callbackParamName;
this.jsonp = jsonp;
this.checkString = checkString;
this.frameDoc = frameDoc;
}
});
=====*/
var loadEvent = dojo.isIE ? "onreadystatechange" : "load",
readyRegExp = /complete|loaded/;
dojo.io.script = {
get: function(/*dojo.io.script.__ioArgs*/args){
// summary:
// sends a get request using a dynamically created script tag.
var dfd = this._makeScriptDeferred(args);
var ioArgs = dfd.ioArgs;
dojo._ioAddQueryToUrl(ioArgs);
dojo._ioNotifyStart(dfd);
if(this._canAttach(ioArgs)){
var node = this.attach(ioArgs.id, ioArgs.url, args.frameDoc);
//If not a jsonp callback or a polling checkString case, bind
//to load event on the script tag.
if(!ioArgs.jsonp && !ioArgs.args.checkString){
var handle = dojo.connect(node, loadEvent, function(evt){
if(evt.type == "load" || readyRegExp.test(node.readyState)){
dojo.disconnect(handle);
ioArgs.scriptLoaded = evt;
}
});
}
}
dojo._ioWatch(dfd, this._validCheck, this._ioCheck, this._resHandle);
return dfd;
},
attach: function(/*String*/id, /*String*/url, /*Document?*/frameDocument){
// summary:
// creates a new <script> tag pointing to the specified URL and
// adds it to the document.
// description:
// Attaches the script element to the DOM. Use this method if you
// just want to attach a script to the DOM and do not care when or
// if it loads.
var doc = (frameDocument || dojo.doc);
var element = doc.createElement("script");
element.type = "text/javascript";
element.src = url;
element.id = id;
element.async = true;
element.charset = "utf-8";
return doc.getElementsByTagName("head")[0].appendChild(element);
},
remove: function(/*String*/id, /*Document?*/frameDocument){
//summary: removes the script element with the given id, from the given frameDocument.
//If no frameDocument is passed, the current document is used.
dojo.destroy(dojo.byId(id, frameDocument));
//Remove the jsonp callback on dojo.io.script, if it exists.
if(this["jsonp_" + id]){
delete this["jsonp_" + id];
}
},
_makeScriptDeferred: function(/*Object*/args){
//summary:
// sets up a Deferred object for an IO request.
var dfd = dojo._ioSetArgs(args, this._deferredCancel, this._deferredOk, this._deferredError);
var ioArgs = dfd.ioArgs;
ioArgs.id = dojo._scopeName + "IoScript" + (this._counter++);
ioArgs.canDelete = false;
//Special setup for jsonp case
ioArgs.jsonp = args.callbackParamName || args.jsonp;
if(ioArgs.jsonp){
//Add the jsonp parameter.
ioArgs.query = ioArgs.query || "";
if(ioArgs.query.length > 0){
ioArgs.query += "&";
}
ioArgs.query += ioArgs.jsonp
+ "="
+ (args.frameDoc ? "parent." : "")
+ dojo._scopeName + ".io.script.jsonp_" + ioArgs.id + "._jsonpCallback";
ioArgs.frameDoc = args.frameDoc;
//Setup the Deferred to have the jsonp callback.
ioArgs.canDelete = true;
dfd._jsonpCallback = this._jsonpCallback;
this["jsonp_" + ioArgs.id] = dfd;
}
return dfd; // dojo.Deferred
},
_deferredCancel: function(/*Deferred*/dfd){
//summary: canceller function for dojo._ioSetArgs call.
//DO NOT use "this" and expect it to be dojo.io.script.
dfd.canceled = true;
if(dfd.ioArgs.canDelete){
dojo.io.script._addDeadScript(dfd.ioArgs);
}
},
_deferredOk: function(/*Deferred*/dfd){
//summary: okHandler function for dojo._ioSetArgs call.
//DO NOT use "this" and expect it to be dojo.io.script.
var ioArgs = dfd.ioArgs;
//Add script to list of things that can be removed.
if(ioArgs.canDelete){
dojo.io.script._addDeadScript(ioArgs);
}
//Favor JSONP responses, script load events then lastly ioArgs.
//The ioArgs are goofy, but cannot return the dfd since that stops
//the callback chain in Deferred. The return value is not that important
//in that case, probably a checkString case.
return ioArgs.json || ioArgs.scriptLoaded || ioArgs;
},
_deferredError: function(/*Error*/error, /*Deferred*/dfd){
//summary: errHandler function for dojo._ioSetArgs call.
if(dfd.ioArgs.canDelete){
//DO NOT use "this" and expect it to be dojo.io.script.
if(error.dojoType == "timeout"){
//For timeouts, remove the script element immediately to
//avoid a response from it coming back later and causing trouble.
dojo.io.script.remove(dfd.ioArgs.id, dfd.ioArgs.frameDoc);
}else{
dojo.io.script._addDeadScript(dfd.ioArgs);
}
}
console.log("dojo.io.script error", error);
return error;
},
_deadScripts: [],
_counter: 1,
_addDeadScript: function(/*Object*/ioArgs){
//summary: sets up an entry in the deadScripts array.
dojo.io.script._deadScripts.push({id: ioArgs.id, frameDoc: ioArgs.frameDoc});
//Being extra paranoid about leaks:
ioArgs.frameDoc = null;
},
_validCheck: function(/*Deferred*/dfd){
//summary: inflight check function to see if dfd is still valid.
//Do script cleanup here. We wait for one inflight pass
//to make sure we don't get any weird things by trying to remove a script
//tag that is part of the call chain (IE 6 has been known to
//crash in that case).
var _self = dojo.io.script;
var deadScripts = _self._deadScripts;
if(deadScripts && deadScripts.length > 0){
for(var i = 0; i < deadScripts.length; i++){
//Remove the script tag
_self.remove(deadScripts[i].id, deadScripts[i].frameDoc);
deadScripts[i].frameDoc = null;
}
dojo.io.script._deadScripts = [];
}
return true;
},
_ioCheck: function(/*Deferred*/dfd){
//summary: inflight check function to see if IO finished.
var ioArgs = dfd.ioArgs;
//Check for finished jsonp
if(ioArgs.json || (ioArgs.scriptLoaded && !ioArgs.args.checkString)){
return true;
}
//Check for finished "checkString" case.
var checkString = ioArgs.args.checkString;
return checkString && eval("typeof(" + checkString + ") != 'undefined'");
},
_resHandle: function(/*Deferred*/dfd){
//summary: inflight function to handle a completed response.
if(dojo.io.script._ioCheck(dfd)){
dfd.callback(dfd);
}else{
//This path should never happen since the only way we can get
//to _resHandle is if _ioCheck is true.
dfd.errback(new Error("inconceivable dojo.io.script._resHandle error"));
}
},
_canAttach: function(/*Object*/ioArgs){
//summary: A method that can be overridden by other modules
//to control when the script attachment occurs.
return true;
},
_jsonpCallback: function(/*JSON Object*/json){
//summary:
// generic handler for jsonp callback. A pointer to this function
// is used for all jsonp callbacks. NOTE: the "this" in this
// function will be the Deferred object that represents the script
// request.
this.ioArgs.json = json;
}
};
return dojo.io.script;
});