|
|
import { NodeOrString, Handle, GenericConstructor } from "./interfaces";
|
|
|
|
|
|
declare namespace dojoQuery {
|
|
|
/* dojo/query */
|
|
|
|
|
|
interface NodeListFilterCallback<T extends Node> {
|
|
|
(item: T, idx: number, nodeList: this): boolean;
|
|
|
}
|
|
|
|
|
|
type NodeListFilter<T extends Node> = string | NodeListFilterCallback<T>;
|
|
|
|
|
|
interface NodeList<T extends Node> extends ArrayLike<T> {
|
|
|
/**
|
|
|
* decorate an array to make it look like a `dojo/NodeList`.
|
|
|
*/
|
|
|
_wrap<U extends Node, V extends Node>(a: U[], parent?: NodeList<V>, NodeListCtor?: NodeListConstructor): NodeList<U>;
|
|
|
|
|
|
_NodeListCtor: NodeListConstructor;
|
|
|
toString(): string;
|
|
|
|
|
|
/**
|
|
|
* private function to hold to a parent NodeList. end() to return the parent NodeList.
|
|
|
*/
|
|
|
_stash(parent: Node): this;
|
|
|
|
|
|
/**
|
|
|
* Listen for events on the nodes in the NodeList.
|
|
|
*/
|
|
|
on(eventName: string, listener: EventListener): Handle[];
|
|
|
|
|
|
/**
|
|
|
* Ends use of the current `NodeList` by returning the previous NodeList
|
|
|
* that generated the current NodeList.
|
|
|
*/
|
|
|
end<U extends Node>(): NodeList<U>;
|
|
|
|
|
|
/**
|
|
|
* Returns a new NodeList, maintaining this one in place
|
|
|
*/
|
|
|
slice(begin: number, end?: number): this;
|
|
|
|
|
|
/**
|
|
|
* Returns a new NodeList, manipulating this NodeList based on
|
|
|
* the arguments passed, potentially splicing in new elements
|
|
|
* at an offset, optionally deleting elements
|
|
|
*/
|
|
|
splice(index: number, howmany?: number, ...items: T[]): this;
|
|
|
|
|
|
/**
|
|
|
* see `dojo/_base/array.indexOf()`. The primary difference is that the acted-on
|
|
|
* array is implicitly this NodeList
|
|
|
*/
|
|
|
indexOf(value: T, fromIndex?: number, findLast?: boolean): number;
|
|
|
|
|
|
/**
|
|
|
* see `dojo/_base/array.lastIndexOf()`. The primary difference is that the
|
|
|
* acted-on array is implicitly this NodeList
|
|
|
*/
|
|
|
lastIndexOf(value: T, fromIndex?: number): number;
|
|
|
|
|
|
/**
|
|
|
* see `dojo/_base/array.every()` and the [Array.every
|
|
|
* docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every).
|
|
|
* Takes the same structure of arguments and returns as
|
|
|
* dojo/_base/array.every() with the caveat that the passed array is
|
|
|
* implicitly this NodeList
|
|
|
*/
|
|
|
every(callback: (item: T, idx: number, nodeList: this) => boolean | string, thisObj?: Object): boolean;
|
|
|
|
|
|
/**
|
|
|
* Takes the same structure of arguments and returns as
|
|
|
* `dojo/_base/array.some()` with the caveat that the passed array as
|
|
|
* implicitly this NodeList. See `dojo/_base/array.some()` and Mozillaas
|
|
|
* [Array.soas
|
|
|
* documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some).
|
|
|
*/
|
|
|
some(callback: (item: T, idx: number, nodeList: this) => boolean | string, thisObj?: Object): boolean;
|
|
|
|
|
|
/**
|
|
|
* Returns a new NodeList comprised of items in this NodeList
|
|
|
* as well as items passed in as parameters
|
|
|
*/
|
|
|
concat(...items: T[]): this;
|
|
|
|
|
|
/**
|
|
|
* see `dojo/_base/array.map()`. The primary difference is that the acted-on
|
|
|
* array is implicitly this NodeList and the return is a
|
|
|
* NodeList (a subclass of Array)
|
|
|
*/
|
|
|
map<U extends Node>(func: (item: T, idx: number, nodeList: this) => U, obj?: Object): NodeList<U>;
|
|
|
|
|
|
/**
|
|
|
* see `dojo/_base/array.forEach()`. The primary difference is that the acted-on
|
|
|
* array is implicitly this NodeList. If you want the option to break out
|
|
|
* of the forEach loop, use every() or some() instead.
|
|
|
*/
|
|
|
forEach(callback: (item: T, idx: number, nodeList: this) => void, thisObj?: Object): this;
|
|
|
|
|
|
/**
|
|
|
* "masks" the built-in javascript filter() method (supported
|
|
|
* in Dojo via `dojo/_base/array.filter`) to support passing a simple
|
|
|
* string filter in addition to supporting filtering function
|
|
|
* objects.
|
|
|
*/
|
|
|
filter<U extends Node>(filter: NodeListFilter<T>, thisObj?: Object): NodeList<U>;
|
|
|
|
|
|
/**
|
|
|
* Create a new instance of a specified class, using the
|
|
|
* specified properties and each node in the NodeList as a
|
|
|
* srcNodeRef.
|
|
|
*/
|
|
|
instantiate(declaredClass: string | GenericConstructor<any>, properties?: Object): this;
|
|
|
|
|
|
/**
|
|
|
* Returns a new NodeList comprised of items in this NodeList
|
|
|
* at the given index or indices.
|
|
|
*/
|
|
|
at(...indices: number[]): this;
|
|
|
|
|
|
}
|
|
|
|
|
|
interface NodeListConstructor {
|
|
|
new <T extends Node>(array: number | Array<T>): NodeList<T>;
|
|
|
new <T extends Node>(...args: T[]): NodeList<T>;
|
|
|
<T extends Node>(array: number | Array<T>): NodeList<T>;
|
|
|
<T extends Node>(...args: T[]): NodeList<T>;
|
|
|
|
|
|
prototype: NodeList<any>;
|
|
|
|
|
|
/**
|
|
|
* decorate an array to make it look like a `dojo/NodeList`.
|
|
|
*/
|
|
|
_wrap<U extends Node, V extends Node>(a: U[], parent?: NodeList<V>, NodeListCtor?: NodeListConstructor): NodeList<U>;
|
|
|
|
|
|
/**
|
|
|
* adapts a single node function to be used in the map-type
|
|
|
* actions. The return is a new array of values, as via `dojo/_base/array.map`
|
|
|
*/
|
|
|
_adaptAsMap<T extends Node, U extends Node>(f: (node: T) => U, o?: Object): NodeList<U>;
|
|
|
|
|
|
/**
|
|
|
* adapts a single node function to be used in the forEach-type
|
|
|
* actions. The initial object is returned from the specialized
|
|
|
* function.
|
|
|
*/
|
|
|
_adaptAsForEach<T extends Node>(f: (node: T) => void, o?: Object): this;
|
|
|
|
|
|
/**
|
|
|
* adapts a single node function to be used in the filter-type actions
|
|
|
*/
|
|
|
_adaptAsFilter<T extends Node>(f: (node: T) => boolean, o?: Object): this;
|
|
|
|
|
|
/**
|
|
|
* adapts a single node function to be used in the map-type
|
|
|
* actions, behaves like forEach() or map() depending on arguments
|
|
|
*/
|
|
|
_adaptWithCondition<T extends Node, U extends Node>(f: (node: T) => U | void, g: (...args: any[]) => boolean, o?: Object): NodeList<U> | this;
|
|
|
}
|
|
|
|
|
|
interface Query {
|
|
|
/**
|
|
|
* Returns nodes which match the given CSS selector, searching the
|
|
|
* entire document by default but optionally taking a node to scope
|
|
|
* the search by. Returns an instance of NodeList.
|
|
|
*/
|
|
|
<T extends Node>(query: string, root?: NodeOrString): NodeList<T>;
|
|
|
|
|
|
/**
|
|
|
* Test to see if a node matches a selector
|
|
|
*/
|
|
|
matches(node: Node, selector: string, root?: NodeOrString): boolean;
|
|
|
|
|
|
/**
|
|
|
* Filters an array of nodes. Note that this does not guarantee to return a NodeList, just an array.
|
|
|
*/
|
|
|
filter<T extends Node>(nodes: NodeList<T> | T[], select: string, root?: NodeOrString): T[] | NodeList<T>;
|
|
|
|
|
|
/**
|
|
|
* can be used as AMD plugin to conditionally load new query engine
|
|
|
*/
|
|
|
load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */
|
|
|
}
|
|
|
}
|
|
|
|
|
|
declare const dojoQuery: dojoQuery.Query;
|
|
|
export = dojoQuery;
|
