diff options
Diffstat (limited to 'lib/dojo/io/script.js.uncompressed.js')
-rw-r--r-- | lib/dojo/io/script.js.uncompressed.js | 256 |
1 files changed, 256 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..628e31948 --- /dev/null +++ b/lib/dojo/io/script.js.uncompressed.js @@ -0,0 +1,256 @@ +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; +}); |