|
|
import { PromiseOrValue, GenericConstructor } from "./interfaces";
|
|
|
import DojoPromise = require("./promise/Promise");
|
|
|
|
|
|
declare namespace dojoParser {
|
|
|
interface ParserOptions { }
|
|
|
|
|
|
interface ParserObjects {
|
|
|
ctor?: GenericConstructor<any>;
|
|
|
types?: string[];
|
|
|
node: Node;
|
|
|
scripts?: HTMLScriptElement[];
|
|
|
inherited?: { [prop: string]: any; };
|
|
|
}
|
|
|
|
|
|
interface InstancesArray extends Array<any>, DojoPromise<any> {}
|
|
|
|
|
|
interface Parser {
|
|
|
/**
|
|
|
* Clear cached data. Used mainly for benchmarking.
|
|
|
*/
|
|
|
_clearCache(): void;
|
|
|
|
|
|
/**
|
|
|
* Convert a `<script type="dojo/method" args="a, b, c"> ... </script>`
|
|
|
* into a function
|
|
|
*/
|
|
|
_functionFromScript(node: HTMLScriptElement, attrData: string): Function;
|
|
|
|
|
|
/**
|
|
|
* Takes array of nodes, and turns them into class instances and
|
|
|
* potentially calls a startup method to allow them to connect with
|
|
|
* any children.
|
|
|
*/
|
|
|
instantiate(nodes: Node[], mixin?: Object, options?: ParserOptions): any[];
|
|
|
|
|
|
/**
|
|
|
* Takes array of objects representing nodes, and turns them into class instances and
|
|
|
* potentially calls a startup method to allow them to connect with
|
|
|
* any children.
|
|
|
*/
|
|
|
_instantiate(nodes: ParserObjects[], mixin?: Object, options?: ParserOptions, returnPromise?: boolean): PromiseOrValue<any[]>;
|
|
|
|
|
|
/**
|
|
|
* Calls new ctor(params, node), where params is the hash of parameters specified on the node,
|
|
|
* excluding data-dojo-type and data-dojo-mixins. Does not call startup().
|
|
|
*/
|
|
|
construct<T>(
|
|
|
ctor: GenericConstructor<T>,
|
|
|
node: Node, mixin?: Object,
|
|
|
options?: ParserOptions,
|
|
|
scripts?: HTMLScriptElement[],
|
|
|
inherited?: { [prop: string]: any; }
|
|
|
): PromiseOrValue<T>;
|
|
|
|
|
|
/**
|
|
|
* Scan a DOM tree and return an array of objects representing the DOMNodes
|
|
|
* that need to be turned into widgets.
|
|
|
*/
|
|
|
scan(root?: Node, options?: ParserOptions): DojoPromise<ParserObjects[]>;
|
|
|
|
|
|
/**
|
|
|
* Helper for _scanAMD(). Takes a `<script type=dojo/require>bar: "acme/bar", ...</script>` node,
|
|
|
* calls require() to load the specified modules and (asynchronously) assign them to the specified global
|
|
|
* variables, and returns a Promise for when that operation completes.
|
|
|
*
|
|
|
* In the example above, it is effectively doing a require(["acme/bar", ...], function(a){ bar = a; }).
|
|
|
*/
|
|
|
_require(script: HTMLScriptElement, options: ParserOptions): DojoPromise<any>;
|
|
|
|
|
|
/**
|
|
|
* Scans the DOM for any declarative requires and returns their values.
|
|
|
*/
|
|
|
_scanAmd(root?: Node, options?: ParserOptions): DojoPromise<boolean>;
|
|
|
|
|
|
/**
|
|
|
* Scan the DOM for class instances, and instantiate them.
|
|
|
*/
|
|
|
parse(rootNode?: Node, options?: ParserOptions): InstancesArray;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
declare const dojoParser: dojoParser.Parser;
|
|
|
export = dojoParser;
|
|
|
|
