public/tt-rss
1
0
Fork 0
mirror of https://git.tt-rss.org/git/tt-rss.git synced 2026-02-10 16:01:33 +00:00
Code Issues Releases Wiki Activity

remove dojo uncompressed files

Browse Source
This commit is contained in:
Andrew Dolgov
2013-04-02 20:06:16 +04:00
parent 7caa48fe6a
commit 870334be3f
806 changed files with 0 additions and 156901 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/dojo/io/iframe.js.uncompressed.js
-190
View File
@@ -1,190 +0,0 @@
define("dojo/io/iframe", [
"../_base/config", "../_base/json", "../_base/kernel", /*===== "../_base/declare", =====*/ "../_base/lang",
"../_base/xhr", "../sniff", "../_base/window",
"../dom", "../dom-construct", "../query", "require", "../aspect", "../request/iframe"
], function(config, json, kernel, /*===== declare, =====*/ lang, xhr, has, win, dom, domConstruct, query, require, aspect, _iframe){
// module:
// dojo/io/iframe
kernel.deprecated("dojo/io/iframe", "Use dojo/request/iframe.", "2.0");
/*=====
var __ioArgs = declare(kernel.__IoArgs, {
// 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 xhr.objectToQuery().
});
=====*/
/*=====
return kernel.io.iframe = {
// summary:
// Deprecated, use dojo/request/iframe instead.
// Sends an Ajax I/O call using and Iframe (for instance, to upload files)
create: function(fname, onloadstr, 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.
},
setSrc: function(iframe, src, 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.
},
doc: function(iframeNode){
// summary:
// Returns the document object associated with the iframe DOM Node argument.
}
};
=====*/
var mid = _iframe._iframeName;
mid = mid.substring(0, mid.lastIndexOf('_'));
var iframe = lang.delegate(_iframe, {
// summary:
// Deprecated, use dojo/request/iframe instead.
// Sends an Ajax I/O call using and Iframe (for instance, to upload files)
create: function(){
return iframe._frame = _iframe.create.apply(_iframe, arguments);
},
// cover up delegated methods
get: null,
post: null,
send: function(/*__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.
var rDfd;
//Set up the deferred.
var dfd = xhr._ioSetArgs(args,
function(/*Deferred*/dfd){
// summary:
// canceller function for xhr._ioSetArgs call.
rDfd && rDfd.cancel();
},
function(/*Deferred*/dfd){
// summary:
// okHandler function for xhr._ioSetArgs call.
var value = null,
ioArgs = dfd.ioArgs;
try{
var handleAs = ioArgs.handleAs;
//Assign correct value based on handleAs value.
if(handleAs === "xml" || handleAs === "html"){
value = rDfd.response.data;
}else{
value = rDfd.response.text;
if(handleAs === "json"){
value = json.fromJson(value);
}else if(handleAs === "javascript"){
value = kernel.eval(value);
}
}
}catch(e){
value = e;
}
return value;
},
function(/*Error*/error, /*Deferred*/dfd){
// summary:
// errHandler function for xhr._ioSetArgs call.
dfd.ioArgs._hasError = true;
return error;
}
);
var ioArgs = dfd.ioArgs;
var method = "GET",
form = dom.byId(args.form);
if(args.method && args.method.toUpperCase() === "POST" && form){
method = "POST";
}
var options = {
method: method,
handleAs: args.handleAs === "json" || args.handleAs === "javascript" ? "text" : args.handleAs,
form: args.form,
query: form ? null : args.content,
data: form ? args.content : null,
timeout: args.timeout,
ioArgs: ioArgs
};
if(options.method){
options.method = options.method.toUpperCase();
}
if(config.ioPublish && kernel.publish && ioArgs.args.ioPublish !== false){
var start = aspect.after(_iframe, "_notifyStart", function(data){
if(data.options.ioArgs === ioArgs){
start.remove();
xhr._ioNotifyStart(dfd);
}
}, true);
}
rDfd = _iframe(ioArgs.url, options, true);
ioArgs._callNext = rDfd._callNext;
rDfd.then(function(){
dfd.resolve(dfd);
}).otherwise(function(error){
dfd.ioArgs.error = error;
dfd.reject(error);
});
return dfd;
},
_iframeOnload: win.global[mid + '_onload']
});
lang.setObject("dojo.io.iframe", iframe);
return iframe;
});
lib/dojo/io/script.js.uncompressed.js
-249
View File
@@ -1,249 +0,0 @@
define("dojo/io/script", [
"../_base/connect", /*===== "../_base/declare", =====*/ "../_base/kernel", "../_base/lang",
"../sniff", "../_base/window","../_base/xhr",
"../dom", "../dom-construct", "../request/script"
], function(connect, /*===== declare, =====*/ kernel, lang, has, win, xhr, dom, domConstruct, _script){
// module:
// dojo/io/script
kernel.deprecated("dojo/io/script", "Use dojo/request/script.", "2.0");
/*=====
var __ioArgs = declare(kernel.__IoArgs, {
// 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.
});
=====*/
var script = {
// summary:
// TODOC
get: function(/*__ioArgs*/ args){
// summary:
// sends a get request using a dynamically created script tag.
var rDfd;
var dfd = this._makeScriptDeferred(args, function(dfd){
rDfd && rDfd.cancel();
});
var ioArgs = dfd.ioArgs;
xhr._ioAddQueryToUrl(ioArgs);
xhr._ioNotifyStart(dfd);
rDfd = _script.get(ioArgs.url, {
timeout: args.timeout,
jsonp: ioArgs.jsonp,
checkString: args.checkString,
ioArgs: ioArgs,
frameDoc: args.frameDoc,
canAttach: function(rDfd){
// sync values
ioArgs.requestId = rDfd.id;
ioArgs.scriptId = rDfd.scriptId;
ioArgs.canDelete = rDfd.canDelete;
return script._canAttach(ioArgs);
}
}, true);
rDfd.then(function(){
dfd.resolve(dfd);
}).otherwise(function(error){
dfd.ioArgs.error = error;
dfd.reject(error);
});
return dfd;
},
attach: _script._attach,
remove: _script._remove,
_makeScriptDeferred: function(/*Object*/ args, /*Function?*/ cancel){
// summary:
// sets up a Deferred object for an IO request.
var dfd = xhr._ioSetArgs(args, cancel || this._deferredCancel, this._deferredOk, this._deferredError);
var ioArgs = dfd.ioArgs;
ioArgs.id = kernel._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." : "") +
kernel._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/_base/Deferred
},
_deferredCancel: function(/*Deferred*/ dfd){
// summary:
// canceller function for xhr._ioSetArgs call.
//DO NOT use "this" and expect it to be script.
dfd.canceled = true;
},
_deferredOk: function(/*Deferred*/ dfd){
// summary:
// okHandler function for xhr._ioSetArgs call.
//DO NOT use "this" and expect it to be script.
var ioArgs = dfd.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 xhr._ioSetArgs call.
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.
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.
// TODO: why isn't dfd accessed?
//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 deadScripts = script._deadScripts;
if(deadScripts && deadScripts.length > 0){
for(var i = 0; i < deadScripts.length; i++){
//Remove the script tag
script.remove(deadScripts[i].id, deadScripts[i].frameDoc);
deadScripts[i].frameDoc = null;
}
script._deadScripts = [];
}
return true;
},
_ioCheck: function(dfd){
// summary:
// inflight check function to see if IO finished.
// dfd: Deferred
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(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(/*===== ioArgs =====*/ ){
// summary:
// A method that can be overridden by other modules
// to control when the script attachment occurs.
// ioArgs: Object
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;
kernel.global[_script._callbacksProperty][this.ioArgs.requestId](json);
}
};
lang.setObject("dojo.io.script", script);
/*=====
script.attach = function(id, url, 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.
};
script.remove = function(id, frameDocument){
// summary:
// removes the script element with the given id, from the given frameDocument.
// If no frameDocument is passed, the current document is used.
};
=====*/
return script;
});