summaryrefslogtreecommitdiff
path: root/lib/dojo/io/script.js.uncompressed.js
diff options
context:
space:
mode:
Diffstat (limited to 'lib/dojo/io/script.js.uncompressed.js')
-rw-r--r--lib/dojo/io/script.js.uncompressed.js249
1 files changed, 249 insertions, 0 deletions
diff --git a/lib/dojo/io/script.js.uncompressed.js b/lib/dojo/io/script.js.uncompressed.js
new file mode 100644
index 000000000..3fea9f208
--- /dev/null
+++ b/lib/dojo/io/script.js.uncompressed.js
@@ -0,0 +1,249 @@
+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;
+});
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-30 12:16:49 +0000