##// END OF EJS Templates
implab » implabjs-dojo-typings
RSS
Added tag v1.0.3 for changeset 1e87acba35f3
Added tag v1.0.3 for changeset 1e87acba35f3
cin - - Load All Authors

File last commit:

r0:ab570232df7d default
r13:063868694d83 default
Show More
io.d.ts
184 lines | 5.6 KiB | video/mp2t | TypeScriptLexer
/ dojo-typings / src / main / typings / dojo / io.d.ts
History | Source | Raw |Copy content |Copy permalink
cin
Initial commit, project structure.
 r0 declare namespace dojo {
namespace io {
/* dojo/io/iframe */
interface IFrameIoArgs extends _base.IoArgs {
/**
* The HTTP method to use. "GET" or "POST" are the only supported
* values. It will try to read the value from the form node's
* method, then try this argument. If neither one exists, then it
* defaults to POST.
*/
method?: string;
/**
* Specifies what format the result data should be given to the
* load/handle callback. Valid values are: text, html, xml, json,
* javascript. IMPORTANT: For all values EXCEPT html and xml, The
* server response should be an HTML file with a textarea element.
* The response data should be inside the textarea element. Using an
* HTML document the only reliable, cross-browser way this
* transport can know when the response has loaded. For the html
* handleAs value, just return a normal HTML document. NOTE: xml
* is now supported with this transport (as of 1.1+); a known issue
* is if the XML document in question is malformed, Internet Explorer
* will throw an uncatchable error.
*/
handleAs?: string;
/**
* If "form" is one of the other args properties, then the content
* object properties become hidden form form elements. For
* instance, a content object of {name1 : "value1"} is converted
* to a hidden form element with a name of "name1" and a value of
* "value1". If there is not a "form" property, then the content
* object is converted into a name=value&name=value string, by
* using xhr.objectToQuery().
*/
content?: Object;
}
interface IFrame {
/**
* Creates a hidden iframe in the page. Used mostly for IO
* transports. You do not need to call this to start a
* dojo/io/iframe request. Just call send().
*/
create(fname: string, onloadstr: string, uri: string): HTMLIFrameElement;
/**
* Sets the URL that is loaded in an IFrame. The replace parameter
* indicates whether location.replace() should be used when
* changing the location of the iframe.
*/
setSrc(iframe: HTMLIFrameElement, src: string, replace?: boolean): void;
/**
* Returns the document object associated with the iframe DOM Node argument.
*/
doc(iframeNode: HTMLIFrameElement): Document;
/**
* Function that sends the request to the server.
* This transport can only process one send() request at a time, so if send() is called
* multiple times, it will queue up the calls and only process one at a time.
*/
send<T>(args: IFrameIoArgs): _base.Deferred<T>;
_iframeOnload: any;
}
/* dojo/io/script */
interface ScriptIoArgs extends _base.IoArgs {
/**
* Deprecated as of Dojo 1.4 in favor of "jsonp", but still supported for
* legacy code. See notes for jsonp property.
*/
callbackParamName: 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".
*/
jsonp: 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).
*/
checkString: string;
/**
* 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.
*/
frameDoc: Document;
}
interface Script {
/**
* sends a get request using a dynamically created script tag.
*/
get<T>(ioArgs: ScriptIoArgs): _base.Deferred<T>;
/**
* creates a new `<script>` tag pointing to the specified URL and
* adds it to the document.
*/
attach(id: string, url: string, frameDoc?: Document): HTMLScriptElement;
/**
* removes the script element with the given id, from the given frameDocument.
* If no frameDocument is passed, the current document is used.
*/
remove(id: string, frameDoc?: Document, cleanup?: boolean): void;
/**
* sets up a Deferred object for an IO request.
*/
_makeScriptDeferred(args: ScriptIoArgs, cancel?: Function): _base.Deferred<any>;
/**
* canceller function for xhr._ioSetArgs call.
*/
_deferredCancel(dfd: _base.Deferred<any>): void;
/**
* okHandler function for xhr._ioSetArgs call.
*/
_deferredOk(dfd: _base.Deferred<any>): void;
/**
* errHandler function for xhr._ioSetArgs call.
*/
_deferredError(error: Error, dfd: _base.Deferred<any>): Error;
_deadScripts: any[];
_counter: number;
/**
* sets up an entry in the deadScripts array.
*/
_addDeadScript(ioArgs: ScriptIoArgs): void;
/**
* inflight check function to see if dfd is still valid.
*/
_validCheck(dfd: _base.Deferred<any>): boolean;
/**
* inflight check function to see if IO finished.
*/
_ioCheck(dfd: _base.Deferred<any>): boolean;
/**
* inflight function to handle a completed response.
*/
_resHandle(dfd: _base.Deferred<any>): void;
/**
* A method that can be overridden by other modules
* to control when the script attachment occurs.
*/
_canAttach(ioArgs: ScriptIoArgs): boolean;
/**
* 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.
*/
_jsonpCallback(json: Object): void;
}
}
}