Page MenuHomeCode
Files F948378

xhr.js
No OneTemporary
Actions

xhr.js
View Options

if(!dojo._hasResource["dojo._base.xhr"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo._base.xhr"] = true;
dojo.provide("dojo._base.xhr");
dojo.require("dojo._base.Deferred");
dojo.require("dojo._base.json");
dojo.require("dojo._base.lang");
dojo.require("dojo._base.query");
(function(){
var _d = dojo;
function setValue(/*Object*/obj, /*String*/name, /*String*/value){
//summary:
// For the nameed property in object, set the value. If a value
// already exists and it is a string, convert the value to be an
// array of values.
var val = obj[name];
if(_d.isString(val)){
obj[name] = [val, value];
}else if(_d.isArray(val)){
val.push(value);
}else{
obj[name] = value;
}
}
dojo.formToObject = function(/*DOMNode||String*/ formNode){
// summary:
// dojo.formToObject returns the values encoded in an HTML form as
// string properties in an object which it then returns. Disabled form
// elements, buttons, and other non-value form elements are skipped.
// Multi-select elements are returned as an array of string values.
// description:
// This form:
//
// <form id="test_form">
// <input type="text" name="blah" value="blah">
// <input type="text" name="no_value" value="blah" disabled>
// <input type="button" name="no_value2" value="blah">
// <select type="select" multiple name="multi" size="5">
// <option value="blah">blah</option>
// <option value="thud" selected>thud</option>
// <option value="thonk" selected>thonk</option>
// </select>
// </form>
//
// yields this object structure as the result of a call to
// formToObject():
//
// {
// blah: "blah",
// multi: [
// "thud",
// "thonk"
// ]
// };
var ret = {};
var iq = "input:not([type=file]):not([type=submit]):not([type=image]):not([type=reset]):not([type=button]), select, textarea";
_d.query(iq, formNode).filter(function(node){
return (!node.disabled);
}).forEach(function(item){
var _in = item.name;
var type = (item.type||"").toLowerCase();
if(type == "radio" || type == "checkbox"){
if(item.checked){ setValue(ret, _in, item.value); }
}else if(item.multiple){
ret[_in] = [];
_d.query("option", item).forEach(function(opt){
if(opt.selected){
setValue(ret, _in, opt.value);
}
});
}else{
setValue(ret, _in, item.value);
if(type == "image"){
ret[_in+".x"] = ret[_in+".y"] = ret[_in].x = ret[_in].y = 0;
}
}
});
return ret; // Object
}
dojo.objectToQuery = function(/*Object*/ map){
// summary:
// takes a key/value mapping object and returns a string representing
// a URL-encoded version of that object.
// example:
// this object:
//
// | {
// | blah: "blah",
// | multi: [
// | "thud",
// | "thonk"
// | ]
// | };
//
// yeilds the following query string:
//
// | "blah=blah&multi=thud&multi=thonk"
// FIXME: need to implement encodeAscii!!
var ec = encodeURIComponent;
var ret = "";
var backstop = {};
for(var x in map){
if(map[x] != backstop[x]){
if(_d.isArray(map[x])){
for(var y=0; y<map[x].length; y++){
ret += ec(x) + "=" + ec(map[x][y]) + "&";
}
}else{
ret += ec(x) + "=" + ec(map[x]) + "&";
}
}
}
if(ret.length && ret.charAt(ret.length-1) == "&"){
ret = ret.substr(0, ret.length-1);
}
return ret; // String
}
dojo.formToQuery = function(/*DOMNode||String*/ formNode){
// summary:
// return URL-encoded string representing the form passed as either a
// node or string ID identifying the form to serialize
return _d.objectToQuery(_d.formToObject(formNode)); // String
}
dojo.formToJson = function(/*DOMNode||String*/ formNode, /*Boolean?*/prettyPrint){
// summary:
// return a serialized JSON string from a form node or string
// ID identifying the form to serialize
return _d.toJson(_d.formToObject(formNode), prettyPrint); // String
}
dojo.queryToObject = function(/*String*/ str){
// summary:
// returns an object representing a de-serialized query section of a
// URL. Query keys with multiple values are returned in an array.
// description:
// This string:
//
// "foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
//
// returns this object structure:
//
// {
// foo: [ "bar", "baz" ],
// thinger: " spaces =blah",
// zonk: "blarg"
// }
//
// Note that spaces and other urlencoded entities are correctly
// handled.
// FIXME: should we grab the URL string if we're not passed one?
var ret = {};
var qp = str.split("&");
var dc = decodeURIComponent;
_d.forEach(qp, function(item){
if(item.length){
var parts = item.split("=");
var name = dc(parts.shift());
var val = dc(parts.join("="));
if(_d.isString(ret[name])){
ret[name] = [ret[name]];
}
if(_d.isArray(ret[name])){
ret[name].push(val);
}else{
ret[name] = val;
}
}
});
return ret; // Object
}
/*
from refactor.txt:
all bind() replacement APIs take the following argument structure:
{
url: "blah.html",
// all below are optional, but must be supported in some form by
// every IO API
timeout: 1000, // milliseconds
handleAs: "text", // replaces the always-wrong "mimetype"
content: {
key: "value"
},
// browser-specific, MAY be unsupported
sync: true, // defaults to false
form: dojo.byId("someForm")
}
*/
// need to block async callbacks from snatching this thread as the result
// of an async callback might call another sync XHR, this hangs khtml forever
// must checked by watchInFlight()
dojo._blockAsync = false;
dojo._contentHandlers = {
"text": function(xhr){ return xhr.responseText; },
"json": function(xhr){
if(!djConfig.usePlainJson){
console.debug("Consider using mimetype:text/json-comment-filtered"
+ " to avoid potential security issues with JSON endpoints"
+ " (use djConfig.usePlainJson=true to turn off this message)");
}
return _d.fromJson(xhr.responseText);
},
"json-comment-filtered": function(xhr){
// NOTE: we provide the json-comment-filtered option as one solution to
// the "JavaScript Hijacking" issue noted by Fortify and others. It is
// not appropriate for all circumstances.
var value = xhr.responseText;
var cStartIdx = value.indexOf("\/*");
var cEndIdx = value.lastIndexOf("*\/");
if(cStartIdx == -1 || cEndIdx == -1){
throw new Error("JSON was not comment filtered");
}
return _d.fromJson(value.substring(cStartIdx+2, cEndIdx));
},
"javascript": function(xhr){
// FIXME: try Moz and IE specific eval variants?
return _d.eval(xhr.responseText);
},
"xml": function(xhr){
if(_d.isIE && !xhr.responseXML){
_d.forEach(["MSXML2", "Microsoft", "MSXML", "MSXML3"], function(i){
try{
var doc = new ActiveXObject(prefixes[i]+".XMLDOM");
doc.async = false;
doc.loadXML(xhr.responseText);
return doc; // DOMDocument
}catch(e){ /* squelch */ };
});
}else{
return xhr.responseXML;
}
}
};
dojo._contentHandlers["json-comment-optional"] = function(xhr){
var handlers = _d._contentHandlers;
try{
return handlers["json-comment-filtered"](xhr);
}catch(e){
return handlers["json"](xhr);
}
};
/*=====
dojo.__ioArgs = function(kwArgs){
// url: String
// URL to server endpoint.
// content: Object?
// Contains properties with string values. These
// properties will be serialized as name1=value2 and
// passed in the request.
// timeout: Integer?
// Milliseconds to wait for the response. If this time
// passes, the then error callbacks are called.
// form: DOMNode?
// DOM node for a form. Used to extract the form values
// and send to the server.
// preventCache: Boolean?
// Default is false. If true, then a
// "dojo.preventCache" parameter is sent in the request
// with a value that changes with each request
// (timestamp). Useful only with GET-type requests.
// handleAs: String?
// Acceptable values depend on the type of IO
// transport (see specific IO calls for more information).
// load: Function?
// function(response, ioArgs){}. response is an Object, ioArgs
// is of type dojo.__ioCallbackArgs. The load function will be
// called on a successful response.
// error: Function?
// function(response, ioArgs){}. response is an Object, ioArgs
// is of type dojo.__ioCallbackArgs. The error function will
// be called in an error case.
// handle: Function
// function(response, ioArgs){}. response is an Object, ioArgs
// is of type dojo.__ioCallbackArgs. The handle function will
// be called in either the successful or error case. For
// the load, error and handle functions, the ioArgs object
// will contain the following properties:
}
=====*/
/*=====
dojo.__ioCallbackArgs = function(kwArgs){
// args: Object
// the original object argument to the IO call.
// xhr: XMLHttpRequest
// For XMLHttpRequest calls only, the
// XMLHttpRequest object that was used for the
// request.
// url: String
// The final URL used for the call. Many times it
// will be different than the original args.url
// value.
// query: String
// For non-GET requests, the
// name1=value1&name2=value2 parameters sent up in
// the request.
// handleAs: String
// The final indicator on how the response will be
// handled.
// id: String
// For dojo.io.script calls only, the internal
// script ID used for the request.
// canDelete: Boolean
// For dojo.io.script calls only, indicates
// whether the script tag that represents the
// request can be deleted after callbacks have
// been called. Used internally to know when
// cleanup can happen on JSONP-type requests.
// json: Object
// For dojo.io.script calls only: holds the JSON
// response for JSONP-type requests. Used
// internally to hold on to the JSON responses.
// You should not need to access it directly --
// the same object should be passed to the success
// callbacks directly.
}
=====*/
dojo._ioSetArgs = function(/*dojo.__ioArgs*/args,
/*Function*/canceller,
/*Function*/okHandler,
/*Function*/errHandler){
// summary:
// sets up the Deferred and ioArgs property on the Deferred so it
// can be used in an io call.
// args:
// The args object passed into the public io call. Recognized properties on
// the args object are:
// canceller:
// The canceller function used for the Deferred object. The function
// will receive one argument, the Deferred object that is related to the
// canceller.
// okHandler:
// The first OK callback to be registered with Deferred. It has the opportunity
// to transform the OK response. It will receive one argument -- the Deferred
// object returned from this function.
// errHandler:
// The first error callback to be registered with Deferred. It has the opportunity
// to do cleanup on an error. It will receive two arguments: error (the
// Error object) and dfd, the Deferred object returned from this function.
var ioArgs = {args: args, url: args.url};
//Get values from form if requestd.
var formObject = null;
if(args.form){
var form = _d.byId(args.form);
//IE requires going through getAttributeNode instead of just getAttribute in some form cases,
//so use it for all. See #2844
var actnNode = form.getAttributeNode("action");
ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null);
formObject = _d.formToObject(form);
}
// set up the query params
var miArgs = [{}];
if(formObject){
// potentially over-ride url-provided params w/ form values
miArgs.push(formObject);
}
if(args.content){
// stuff in content over-rides what's set by form
miArgs.push(args.content);
}
if(args.preventCache){
miArgs.push({"dojo.preventCache": new Date().valueOf()});
}
ioArgs.query = _d.objectToQuery(_d.mixin.apply(null, miArgs));
// .. and the real work of getting the deferred in order, etc.
ioArgs.handleAs = args.handleAs || "text";
var d = new _d.Deferred(canceller);
d.addCallbacks(okHandler, function(error){
return errHandler(error, d);
});
//Support specifying load, error and handle callback functions from the args.
//For those callbacks, the "this" object will be the args object.
//The callbacks will get the deferred result value as the
//first argument and the ioArgs object as the second argument.
var ld = args.load;
if(ld && _d.isFunction(ld)){
d.addCallback(function(value){
return ld.call(args, value, ioArgs);
});
}
var err = args.error;
if(err && _d.isFunction(err)){
d.addErrback(function(value){
return err.call(args, value, ioArgs);
});
}
var handle = args.handle;
if(handle && _d.isFunction(handle)){
d.addBoth(function(value){
return handle.call(args, value, ioArgs);
});
}
d.ioArgs = ioArgs;
// FIXME: need to wire up the xhr object's abort method to something
// analagous in the Deferred
return d;
}
var _deferredCancel = function(/*Deferred*/dfd){
//summary: canceller function for dojo._ioSetArgs call.
dfd.canceled = true;
var xhr = dfd.ioArgs.xhr;
var _at = (typeof xhr.abort);
if((_at == "function")||(_at == "unknown")){
xhr.abort();
}
var err = new Error("xhr cancelled");
err.dojoType = "cancel";
return err;
}
var _deferredOk = function(/*Deferred*/dfd){
//summary: okHandler function for dojo._ioSetArgs call.
return _d._contentHandlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
}
var _deferError = function(/*Error*/error, /*Deferred*/dfd){
//summary: errHandler function for dojo._ioSetArgs call.
// console.debug("xhr error in:", dfd.ioArgs.xhr);
console.debug(error);
return error;
}
var _makeXhrDeferred = function(/*dojo.__xhrArgs*/args){
//summary: makes the Deferred object for this xhr request.
var dfd = _d._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError);
//Pass the args to _xhrObj, to allow xhr iframe proxy interceptions.
dfd.ioArgs.xhr = _d._xhrObj(dfd.ioArgs.args);
return dfd;
}
// avoid setting a timer per request. It degrades performance on IE
// something fierece if we don't use unified loops.
var _inFlightIntvl = null;
var _inFlight = [];
var _watchInFlight = function(){
//summary:
// internal method that checks each inflight XMLHttpRequest to see
// if it has completed or if the timeout situation applies.
var now = (new Date()).getTime();
// make sure sync calls stay thread safe, if this callback is called
// during a sync call and this results in another sync call before the
// first sync call ends the browser hangs
if(!_d._blockAsync){
// we need manual loop because we often modify _inFlight (and therefore 'i') while iterating
// note: the second clause is an assigment on purpose, lint may complain
for(var i=0, tif; (i<_inFlight.length)&&(tif=_inFlight[i]); i++){
var dfd = tif.dfd;
try{
if(!dfd || dfd.canceled || !tif.validCheck(dfd)){
_inFlight.splice(i--, 1);
}else if(tif.ioCheck(dfd)){
_inFlight.splice(i--, 1);
tif.resHandle(dfd);
}else if(dfd.startTime){
//did we timeout?
if(dfd.startTime + (dfd.ioArgs.args.timeout||0) < now){
_inFlight.splice(i--, 1);
var err = new Error("timeout exceeded");
err.dojoType = "timeout";
dfd.errback(err);
//Cancel the request so the io module can do appropriate cleanup.
dfd.cancel();
}
}
}catch(e){
// FIXME: make sure we errback!
console.debug(e);
dfd.errback(new Error("_watchInFlightError!"));
}
}
}
if(!_inFlight.length){
clearInterval(_inFlightIntvl);
_inFlightIntvl = null;
return;
}
}
dojo._ioCancelAll = function(){
//summary: Cancels all pending IO requests, regardless of IO type
//(xhr, script, iframe).
try{
_d.forEach(_inFlight, function(i){
i.dfd.cancel();
});
}catch(e){/*squelch*/}
}
//Automatically call cancel all io calls on unload
//in IE for trac issue #2357.
if(_d.isIE){
_d.addOnUnload(_d._ioCancelAll);
}
_d._ioWatch = function(/*Deferred*/dfd,
/*Function*/validCheck,
/*Function*/ioCheck,
/*Function*/resHandle){
//summary: watches the io request represented by dfd to see if it completes.
//dfd:
// The Deferred object to watch.
//validCheck:
// Function used to check if the IO request is still valid. Gets the dfd
// object as its only argument.
//ioCheck:
// Function used to check if basic IO call worked. Gets the dfd
// object as its only argument.
//resHandle:
// Function used to process response. Gets the dfd
// object as its only argument.
if(dfd.ioArgs.args.timeout){
dfd.startTime = (new Date()).getTime();
}
_inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle});
if(!_inFlightIntvl){
_inFlightIntvl = setInterval(_watchInFlight, 50);
}
_watchInFlight(); // handle sync requests
}
var _defaultContentType = "application/x-www-form-urlencoded";
var _validCheck = function(/*Deferred*/dfd){
return dfd.ioArgs.xhr.readyState; //boolean
}
var _ioCheck = function(/*Deferred*/dfd){
return 4 == dfd.ioArgs.xhr.readyState; //boolean
}
var _resHandle = function(/*Deferred*/dfd){
if(_d._isDocumentOk(dfd.ioArgs.xhr)){
dfd.callback(dfd);
}else{
dfd.errback(new Error("bad http response code:" + dfd.ioArgs.xhr.status));
}
}
var _doIt = function(/*String*/type, /*Deferred*/dfd){
// IE 6 is a steaming pile. It won't let you call apply() on the native function (xhr.open).
// workaround for IE6's apply() "issues"
var ioArgs = dfd.ioArgs;
var args = ioArgs.args;
ioArgs.xhr.open(type, ioArgs.url, args.sync !== true, args.user || undefined, args.password || undefined);
if(args.headers){
for(var hdr in args.headers){
if(hdr.toLowerCase() === "content-type" && !args.contentType){
args.contentType = args.headers[hdr];
}else{
ioArgs.xhr.setRequestHeader(hdr, args.headers[hdr]);
}
}
}
// FIXME: is this appropriate for all content types?
ioArgs.xhr.setRequestHeader("Content-Type", (args.contentType||_defaultContentType));
// FIXME: set other headers here!
try{
ioArgs.xhr.send(ioArgs.query);
}catch(e){
dfd.cancel();
}
_d._ioWatch(dfd, _validCheck, _ioCheck, _resHandle);
return dfd; //Deferred
}
dojo._ioAddQueryToUrl = function(/*dojo.__ioCallbackArgs*/ioArgs){
//summary: Adds query params discovered by the io deferred construction to the URL.
//Only use this for operations which are fundamentally GET-type operations.
if(ioArgs.query.length){
ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query;
ioArgs.query = null;
}
}
/*=====
dojo.__xhrArgs = function(kwArgs){
// summary:
// In addition to the properties listed for the dojo.__ioArgs type,
// the following properties are allowed for dojo.xhr* methods.
// handleAs:
// String. Acceptable values are:
// "text" (default)
// "json"
// "json-comment-optional"
// "json-comment-filtered"
// "javascript"
// "xml"
// sync:
// Boolean. false is default. Indicates whether the request should
// be a synchronous (blocking) request.
// headers:
// Object. Additional HTTP headers to send in the request.
}
=====*/
dojo.xhrGet = function(/*dojo.__xhrArgs*/ args){
// summary:
// Sends an HTTP GET request to the server.
var dfd = _makeXhrDeferred(args);
_d._ioAddQueryToUrl(dfd.ioArgs);
return _doIt("GET", dfd); // dojo.Deferred
}
dojo.xhrPost = function(/*dojo.__xhrArgs*/ args){
//summary:
// Sends an HTTP POST request to the server.
return _doIt("POST", _makeXhrDeferred(args)); // dojo.Deferred
}
dojo.rawXhrPost = function(/*dojo.__xhrArgs*/ args){
// summary:
// Sends an HTTP POST request to the server. In addtion to the properties
// listed for the dojo.__xhrArgs type, the following property is allowed:
// postData:
// String. The raw data to send in the body of the POST request.
var dfd = _makeXhrDeferred(args);
dfd.ioArgs.query = args.postData;
return _doIt("POST", dfd); // dojo.Deferred
}
dojo.xhrPut = function(/*dojo.__xhrArgs*/ args){
// summary:
// Sends an HTTP PUT request to the server.
return _doIt("PUT", _makeXhrDeferred(args)); // dojo.Deferred
}
dojo.rawXhrPut = function(/*dojo.__xhrArgs*/ args){
// summary:
// Sends an HTTP PUT request to the server. In addtion to the properties
// listed for the dojo.__xhrArgs type, the following property is allowed:
// putData:
// String. The raw data to send in the body of the PUT request.
var dfd = _makeXhrDeferred(args);
var ioArgs = dfd.ioArgs;
if(args["putData"]){
ioArgs.query = args.putData;
args.putData = null;
}
return _doIt("PUT", dfd); // dojo.Deferred
}
dojo.xhrDelete = function(/*dojo.__xhrArgs*/ args){
// summary:
// Sends an HTTP DELETE request to the server.
var dfd = _makeXhrDeferred(args);
_d._ioAddQueryToUrl(dfd.ioArgs);
return _doIt("DELETE", dfd); // dojo.Deferred
}
/*
dojo.wrapForm = function(formNode){
//summary:
// A replacement for FormBind, but not implemented yet.
// FIXME: need to think harder about what extensions to this we might
// want. What should we allow folks to do w/ this? What events to
// set/send?
throw new Error("dojo.wrapForm not yet implemented");
}
*/
})();
}

File Metadata

Mime Type
text/plain
Expires
Sat, Apr 26, 16:06 (5 h, 55 m ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
25661
Default Alt Text
xhr.js (21 KB)

Event Timeline