|
|
import { GenericObject } from "../interfaces";
|
|
|
import DojoPromise = require("../promise/Promise");
|
|
|
import { XhrBaseOptions, DojoRequestPromise } from "../request";
|
|
|
import Deferred = require("./Deferred");
|
|
|
|
|
|
declare namespace xhr {
|
|
|
interface IoArgs {
|
|
|
/**
|
|
|
* URL to server endpoint.
|
|
|
*/
|
|
|
url: string;
|
|
|
|
|
|
/**
|
|
|
* Contains properties with string values. These
|
|
|
* properties will be serialized as name1=value2 and
|
|
|
* passed in the request.
|
|
|
*/
|
|
|
content?: GenericObject;
|
|
|
|
|
|
/**
|
|
|
* Milliseconds to wait for the response. If this time
|
|
|
* passes, the then error callbacks are called.
|
|
|
*/
|
|
|
timeout?: number;
|
|
|
|
|
|
/**
|
|
|
* DOM node for a form. Used to extract the form values
|
|
|
* and send to the server.
|
|
|
*/
|
|
|
form?: HTMLFormElement;
|
|
|
|
|
|
/**
|
|
|
* Default is false. If true, then a
|
|
|
* "dojo.preventCache" parameter is sent in the requesa
|
|
|
* with a value that changes with each requesa
|
|
|
* (timestamp). Useful only with GET-type requests.
|
|
|
*/
|
|
|
preventCache?: boolean;
|
|
|
|
|
|
/**
|
|
|
* Acceptable values depend on the type of IO
|
|
|
* transport (see specific IO calls for more information).
|
|
|
*/
|
|
|
handleAs?: string;
|
|
|
|
|
|
/**
|
|
|
* Sets the raw body for an HTTP request. If this is used, then the content
|
|
|
* property is ignored. This is mostly useful for HTTP methods that have
|
|
|
* a body to their requests, like PUT or POST. This property can be used instead
|
|
|
* of postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.
|
|
|
*/
|
|
|
rawBody?: string;
|
|
|
|
|
|
/**
|
|
|
* Set this explicitly to false to prevent publishing of topics related to
|
|
|
* IO operations. Otherwise, if djConfig.ioPublish is set to true, topics
|
|
|
* will be published via dojo/topic.publish() for different phases of an IO operation.
|
|
|
* See dojo/main.__IoPublish for a list of topics that are published.
|
|
|
*/
|
|
|
ioPublish?: boolean;
|
|
|
|
|
|
/**
|
|
|
* This function will be
|
|
|
* called on a successful HTTP response code.
|
|
|
*/
|
|
|
load?: (response: any, ioArgs: IoCallbackArgs) => void;
|
|
|
|
|
|
/**
|
|
|
* This function will
|
|
|
* be called when the request fails due to a network or server error, the url
|
|
|
* is invalid, etc. It will also be called if the load or handle callback throws an
|
|
|
* exception, unless djConfig.debugAtAllCosts is true. This allows deployed applications
|
|
|
* to continue to run even when a logic error happens in the callback, while making
|
|
|
* it easier to troubleshoot while in debug mode.
|
|
|
*/
|
|
|
error?: (response: any, ioArgs: IoCallbackArgs) => void;
|
|
|
|
|
|
/**
|
|
|
* This function will
|
|
|
* be called at the end of every request, whether or not an error occurs.
|
|
|
*/
|
|
|
handle?: (loadOrError: string, response: any, ioArgs: IoCallbackArgs) => void;
|
|
|
}
|
|
|
|
|
|
interface IoCallbackArgs {
|
|
|
/**
|
|
|
* the original object argument to the IO call.
|
|
|
*/
|
|
|
args: GenericObject;
|
|
|
|
|
|
/**
|
|
|
* For XMLHttpRequest calls only, the
|
|
|
* XMLHttpRequest object that was used for the
|
|
|
* request.
|
|
|
*/
|
|
|
xhr: XMLHttpRequest;
|
|
|
|
|
|
/**
|
|
|
* The final URL used for the call. Many times it
|
|
|
* will be different than the original args.url
|
|
|
* value.
|
|
|
*/
|
|
|
url: string;
|
|
|
|
|
|
/**
|
|
|
* For non-GET requests, the
|
|
|
* name1=value1&name2=value2 parameters sent up in
|
|
|
* the request.
|
|
|
*/
|
|
|
query: string;
|
|
|
|
|
|
/**
|
|
|
* The final indicator on how the response will be
|
|
|
* handled.
|
|
|
*/
|
|
|
handleAs: string;
|
|
|
|
|
|
/**
|
|
|
* For dojo/io/script calls only, the internal
|
|
|
* script ID used for the request.
|
|
|
*/
|
|
|
id?: string;
|
|
|
|
|
|
/**
|
|
|
* 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.
|
|
|
*/
|
|
|
canDelete?: boolean;
|
|
|
|
|
|
/**
|
|
|
* 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.
|
|
|
*/
|
|
|
json?: GenericObject;
|
|
|
}
|
|
|
|
|
|
interface XhrArgs extends IoArgs {
|
|
|
/**
|
|
|
* Acceptable values are: text (default), json, json-comment-optional,
|
|
|
* json-comment-filtered, javascript, xml. See `dojo/_base/xhr.contentHandlers`
|
|
|
*/
|
|
|
handleAs?: string;
|
|
|
|
|
|
/**
|
|
|
* false is default. Indicates whether the request should
|
|
|
* be a synchronous (blocking) request.
|
|
|
*/
|
|
|
sync?: boolean;
|
|
|
|
|
|
/**
|
|
|
* Additional HTTP headers to send in the request.
|
|
|
*/
|
|
|
headers?: GenericObject;
|
|
|
|
|
|
/**
|
|
|
* false is default. Indicates whether a request should be
|
|
|
* allowed to fail (and therefore no console error message in
|
|
|
* the event of a failure)
|
|
|
*/
|
|
|
failOk?: boolean;
|
|
|
|
|
|
/**
|
|
|
* "application/x-www-form-urlencoded" is default. Set to false to
|
|
|
* prevent a Content-Type header from being sent, or to a string
|
|
|
* to send a different Content-Type.
|
|
|
*/
|
|
|
contentType: boolean | string;
|
|
|
}
|
|
|
|
|
|
interface ContentHandlers {
|
|
|
'text': (xhr: { responseText: string }) => string;
|
|
|
'json': (xhr: { responseText: string }) => GenericObject;
|
|
|
'json-comment-filtered': (xhr: { responseText: string }) => GenericObject;
|
|
|
'javascript': (xhr: { responseText: string }) => any;
|
|
|
'xml': (xhr: { responseXML: string }) => Document;
|
|
|
'json-comment-optional': (xhr: { responseText: string }) => GenericObject;
|
|
|
[type: string]: (xhr: { responseText: string, responseXML: string }) => any;
|
|
|
}
|
|
|
|
|
|
interface Xhr {
|
|
|
(method: string, args: XhrArgs, hasBody?: boolean): Deferred<any>;
|
|
|
|
|
|
/**
|
|
|
* does the work of portably generating a new XMLHTTPRequest object.
|
|
|
*/
|
|
|
_xhrObj(): XMLHttpRequest | ActiveXObject;
|
|
|
|
|
|
/**
|
|
|
* Serialize a form field to a JavaScript object.
|
|
|
*/
|
|
|
fieldToObject(inputNode: HTMLElement | string): GenericObject;
|
|
|
|
|
|
/**
|
|
|
* Serialize a form node to a JavaScript object.
|
|
|
*/
|
|
|
formToObject(fromNode: HTMLFormElement | string): GenericObject;
|
|
|
|
|
|
/**
|
|
|
* takes a name/value mapping object and returns a string representing
|
|
|
* a URL-encoded version of that object.
|
|
|
*/
|
|
|
objectToQuery(map: GenericObject): string;
|
|
|
|
|
|
/**
|
|
|
* Returns a URL-encoded string representing the form passed as either a
|
|
|
* node or string ID identifying the form to serialize
|
|
|
*/
|
|
|
formToQuery(fromNode: HTMLFormElement | string): string;
|
|
|
|
|
|
/**
|
|
|
* Create a serialized JSON string from a form node or string
|
|
|
* ID identifying the form to serialize
|
|
|
*/
|
|
|
formToJson(formNode: HTMLFormElement | string): string;
|
|
|
|
|
|
/**
|
|
|
* Create an object representing a de-serialized query section of a
|
|
|
* URL. Query keys with multiple values are returned in an array.
|
|
|
*/
|
|
|
queryToObject(str: string): GenericObject;
|
|
|
|
|
|
/**
|
|
|
* A map of available XHR transport handle types. Name matches the
|
|
|
* `handleAs` attribute passed to XHR calls.
|
|
|
*/
|
|
|
contentHandlers: ContentHandlers;
|
|
|
|
|
|
_ioCancelAll(): void;
|
|
|
|
|
|
/**
|
|
|
* If dojo.publish is available, publish topics
|
|
|
* about the start of a request queue and/or the
|
|
|
* the beginning of request.
|
|
|
*
|
|
|
* Used by IO transports. An IO transport should
|
|
|
* call this method before making the network connection.
|
|
|
*/
|
|
|
_ioNotifyStart<T>(dfd: DojoPromise<T>): void;
|
|
|
|
|
|
/**
|
|
|
* Watches the io request represented by dfd to see if it completes.
|
|
|
*/
|
|
|
_ioWatch<T>(dfd: DojoPromise<T>, validCheck: Function, ioCheck: Function, resHandle: Function): void;
|
|
|
|
|
|
/**
|
|
|
* Adds query params discovered by the io deferred construction to the URL.
|
|
|
* Only use this for operations which are fundamentally GET-type operations.
|
|
|
*/
|
|
|
_ioAddQueryToUrl(ioArgs: IoCallbackArgs): void;
|
|
|
|
|
|
/**
|
|
|
* sets up the Deferred and ioArgs property on the Deferred so it
|
|
|
* can be used in an io call.
|
|
|
*/
|
|
|
_ioSetArgs(args: IoArgs, canceller: Function, okHandler: Function, errHandler: Function): Deferred<any>;
|
|
|
|
|
|
_isDocumentOk(x: Document): boolean;
|
|
|
|
|
|
_getText(url: string): string;
|
|
|
|
|
|
/**
|
|
|
* Send an HTTP GET request using the default transport for the current platform.
|
|
|
*/
|
|
|
get<T>(url: string, options?: XhrBaseOptions): DojoRequestPromise<T>;
|
|
|
|
|
|
/**
|
|
|
* Send an HTTP POST request using the default transport for the current platform.
|
|
|
*/
|
|
|
post<T>(url: string, options?: XhrBaseOptions): DojoRequestPromise<T>;
|
|
|
|
|
|
/**
|
|
|
* Send an HTTP PUT request using the default transport for the current platform.
|
|
|
*/
|
|
|
put<T>(url: string, options?: XhrBaseOptions): DojoRequestPromise<T>;
|
|
|
|
|
|
/**
|
|
|
* Send an HTTP DELETE request using the default transport for the current platform.
|
|
|
*/
|
|
|
del<T>(url: string, options?: XhrBaseOptions): DojoRequestPromise<T>;
|
|
|
}
|
|
|
}
|
