dojo/io/script.js

  • Provides:

    • dojo.io.script

  • dojo.io.script.__ioArgs

    • type
      Function
    • chains:
      • dojo.__IoArgs: (prototype)
      • dojo.__IoArgs: (call)
    • source: [view]
        this.callbackParamName = callbackParamName;
        this.jsonp = jsonp;
        this.checkString = checkString;
        this.frameDoc = frameDoc;
    • 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.

  • dojo.io.script.__ioArgs.callbackParamName

    • type
      String
    • summary
      Deprecated as of Dojo 1.4 in favor of "jsonp", but still supported for
legacy code. See notes for jsonp property.

  • dojo.io.script.__ioArgs.jsonp

    • type
      c".
    • summary
  • dojo.io.script.__ioArgs.checkString
       
    • type
      String
    • summary
      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).
  • dojo.io.script.__ioArgs.frameDoc
       
    • type
      Document
    • summary
      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.
  • readyRegExp
       
    • summary
  • dojo.io.script
       
    • type
      Object
    • summary
  • dojo.io.script.get
       
    • type
      Function
    • parameters: 
      • args: (typeof dojo.io.script.__ioArgs)
    • source: [view] 
                    
      

                       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;
                    
      
                    
    • summary
      sends a get request using a dynamically created script tag.
  • dojo.io.script.attach
       
    • type
      Function
    • parameters: 
      • id: (typeof String)
      • url: (typeof String)
      • frameDocument: (typeof Document)
    • source: [view] 
                    
      

                       var doc = (frameDocument || dojo.doc);
         var element = doc.createElement("script");
         element.type = "text/javascript";
         element.src = url;
         element.id = id;
         element.charset = "utf-8";
         return doc.getElementsByTagName("head")[0].appendChild(element);
                    
      
                    
    • 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.
  • dojo.io.script.remove
       
    • type
      Function
    • parameters: 
      • id: (typeof String)
      • frameDocument: (typeof Document)
    • source: [view] 
                    
      

                       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];
         }
                    
      
                    
    • summary
      removes the script element with the given id, from the given frameDocument.
If no frameDocument is passed, the current document is used.
  • dojo.io.script._makeScriptDeferred
       
    • type
      Function
    • parameters: 
      • args: (typeof Object)
    • source: [view] 
                    
      

                       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
                    
      
                    
    • summary
      sets up a Deferred object for an IO request.
    • returns
      dojo.Deferred
  • dojo.io.script._deferredCancel
       
    • type
      Function
    • parameters: 
      • dfd: (typeof Deferred)
    • source: [view] 
                    
      

                       dfd.canceled = true;
         if(dfd.ioArgs.canDelete){
          dojo.io.script._addDeadScript(dfd.ioArgs);
         }
                    
      
                    
    • summary
      canceller function for dojo._ioSetArgs call.

DO NOT use "this" and expect it to be dojo.io.script.
  • dojo.io.script._deferredOk
       
    • type
      Function
    • parameters: 
      • dfd: (typeof Deferred)
    • source: [view] 
                    
      

                       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;
                    
      
                    
    • summary
      okHandler function for dojo._ioSetArgs call.

DO NOT use "this" and expect it to be dojo.io.script.
  • dojo.io.script._deferredError
       
    • type
      Function
    • parameters: 
      • error: (typeof Error)
      • dfd: (typeof Deferred)
    • source: [view] 
                    
      

                       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;
                    
      
                    
    • summary
      errHandler function for dojo._ioSetArgs call.
  • dojo.io.script._deadScripts
       
    • summary
  • dojo.io.script._counter
       
    • summary
  • dojo.io.script._addDeadScript
       
    • type
      Function
    • parameters: 
      • ioArgs: (typeof Object)
    • source: [view] 
                    
      

                       dojo.io.script._deadScripts.push({id: ioArgs.id, frameDoc: ioArgs.frameDoc});
         //Being extra paranoid about leaks:
         ioArgs.frameDoc = null;
                    
      
                    
    • summary
      sets up an entry in the deadScripts array.
  • dojo.io.script._validCheck
       
    • type
      Function
    • parameters: 
      • dfd: (typeof Deferred)
    • source: [view] 
                    
      

                       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;
                    
      
                    
    • 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).
  • dojo.io.script._ioCheck
       
    • type
      Function
    • parameters: 
      • dfd: (typeof Deferred)
    • source: [view] 
                    
      

                       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;
         if(checkString && eval("typeof(" + checkString + ") != 'undefined'")){
          return true;
         }

       
         return false;
                    
      
                    
    • summary
      inflight check function to see if IO finished.
  • dojo.io.script._resHandle
       
    • type
      Function
    • parameters: 
      • dfd: (typeof Deferred)
    • source: [view] 
                    
      

                       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"));
         }
                    
      
                    
    • summary
      inflight function to handle a completed response.
  • dojo.io.script._canAttach
       
    • type
      Function
    • parameters: 
      • ioArgs: (typeof Object)
    • source: [view] 
                    
      

                       return true;
                    
      
                    
    • summary
      A method that can be overridden by other modules
to control when the script attachment occurs.
  • dojo.io.script._jsonpCallback
       
    • type
      Function
    • parameters: 
      • json: (typeof JSON Object)
    • source: [view] 
                    
      

                       this.ioArgs.json = json;
                    
      
                    
    • summary
      generic handler for jsonp callback. A pointer to this function
is used for all jsonp callbacks.  NOTE: the &quot;this&quot; in this
function will be the Deferred object that represents the script
request.
  • dojo.io.script._jsonpCallback.ioArgs.json
       
    • summary
  • dojo.io
       
    • type
      Object
    • summary
  • dojo
       
    • type
      Object
    • summary