##// END OF EJS Templates
implab » implabjs-dojo-typings
RSS
`dojo.store.api` replaced `dojo.promise.Promise<T>` with `PromiseLike<T>` type
`dojo.store.api` replaced `dojo.promise.Promise<T>` with `PromiseLike<T>` type
cin - - Load All Authors

File last commit:

r0:ab570232df7d default
r12:1e87acba35f3 v1.0.3 default
Show More
data.d.ts
934 lines | 26.8 KiB | video/mp2t | TypeScriptLexer
/ dojo-typings / src / main / typings / dojo / data.d.ts
History | Source | Raw |Copy content |Copy permalink
cin
Initial commit, project structure.
 r0 declare namespace dojo {
namespace data {
namespace api {
/* dojo/data/api/Identity */
interface Features {
'dojo.data.api.Identity'?: boolean;
}
interface FetchByIdentityArgs<T extends Item> {
identity?: string | Object;
onItem?: (item: T) => void;
onError?: (err: Error) => void;
scope?: Object;
}
interface Identity<T extends Item> {
/**
* See dojo/data/api/Read.getFeatures()
*/
getFeatures(): Features;
/**
* Returns a unique identifier for an item. The return value will be
* either a string or something that has a toString() method (such as,
* for example, a dojox/uuid object).
*/
getIdentity(item: T): Object | string | number;
/**
* Returns an array of attribute names that are used to generate the identity.
* For most stores, this is a single attribute, but for some complex stores
* such as RDB backed stores that use compound (multi-attribute) identifiers
* it can be more than one. If the identity is not composed of attributes
* on the item, it will return null. This function is intended to identify
* the attributes that comprise the identity so that so that during a render
* of all attributes, the UI can hide the the identity information if it
* chooses.
*/
getIdentity(item: T): string[];
/**
* Given the identity of an item, this method returns the item that has
* that identity through the onItem callback. Conforming implementations
* should return null if there is no item with the given identity.
* Implementations of fetchItemByIdentity() may sometimes return an item
* from a local cache and may sometimes fetch an item from a remote server,
*/
fetchItemByIdentity(keywordArgs: FetchByIdentityArgs<T>): T;
}
interface IdentityConstructor {
new <T extends Item>(): Identity<T>;
prototype: Identity<any>;
}
/* dojo/data/api/Item */
/**
* An item in a dojo/data store
* Class for documentation purposes only. An item can take any form, so no
* properties or methods are defined here.
*/
interface Item {
[property: string]: any;
}
interface ItemConstructor {
new (): Item;
prototype: Item;
}
/* dojo/data/api/Notification */
interface ParentInfo<T> {
item: T;
attribute: string;
oldValue: any;
}
interface Features {
'dojo.data.api.Notification': boolean;
}
interface Notification<T extends Item> {
/**
* See dojo/data/api/Read.getFeatures()
*/
getFeatures(): Features;
/**
* This function is called any time an item is modified via setValue, setValues, unsetAttribute, etc.
*/
onSet(item: T, attribute: string, oldValue: any, newValue: any): void;
/**
* This function is called any time a new item is created in the store.
* It is called immediately after the store newItem processing has completed.
*/
onNew(item: T, parentInfo?: ParentInfo<T>): void;
/**
* This function is called any time an item is deleted from the store.
* It is called immediately after the store deleteItem processing has completed.
*/
onDelete(deletedItem: T): void;
}
interface NotificationConstructor {
new <T extends Item>(): Notification<T>;
prototype: Notification<Item>;
}
/* dojo/data/api/Read */
interface Features {
'dojo.data.api.Read'?: boolean;
}
interface LoadItemArgs<T extends Item> {
item?: T;
onItem?: (item: T) => void;
onError?: (err: Error) => void;
scope?: Object;
}
interface SortArg {
attribute: string;
descending?: boolean;
}
interface FetchArgs<T extends Item> {
query?: Object | string;
queryOptions?: Object;
onBegin?: (size: number, request: Request) => void;
onItem?: (item: T, request: Request) => void;
onComplete?: (items: T[], request: Request) => void;
onError?: (errorData: Error, request: Request) => void;
scope?: Object;
start?: number;
count?: number;
sort?: SortArg[];
}
interface Read<T extends Item> {
/**
* Returns a single attribute value.
* Returns defaultValue if and only if *item* does not have a value for *attribute*.
* Returns null if and only if null was explicitly set as the attribute value.
* Returns undefined if and only if the item does not have a value for the
* given attribute (which is the same as saying the item does not have the attribute).
*/
getValue<U>(item: T, attribute: string, defaultValue?: U): U;
/**
* This getValues() method works just like the getValue() method, but getValues()
* always returns an array rather than a single attribute value. The array
* may be empty, may contain a single attribute value, or may contain
* many attribute values.
* If the item does not have a value for the given attribute, then getValues()
* will return an empty array: []. (So, if store.hasAttribute(item, attribute)
* has a return of false, then store.getValues(item, attribute) will return [].)
*/
getValues<U>(item: T, attribute: string): U[];
/**
* Returns an array with all the attributes that this item has. This
* method will always return an array; if the item has no attributes
* at all, getAttributes() will return an empty array: [].
*/
getAttributes(item: T): string[];
/**
* Returns true if the given *item* has a value for the given *attribute*.
*/
hasAttribute(item: T, attribute: string): boolean;
/**
* Returns true if the given *value* is one of the values that getValues()
* would return.
*/
containsValue(item: T, attribute: string, value: any): boolean;
/**
* Returns true if *something* is an item and came from the store instance.
* Returns false if *something* is a literal, an item from another store instance,
* or is any object other than an item.
*/
isItem(something: any): something is T;
/**
* Returns false if isItem(something) is false. Returns false if
* if isItem(something) is true but the the item is not yet loaded
* in local memory (for example, if the item has not yet been read
* from the server).
*/
isItemLoaded(something: any): boolean;
/**
* Given an item, this method loads the item so that a subsequent call
* to store.isItemLoaded(item) will return true. If a call to
* isItemLoaded() returns true before loadItem() is even called,
* then loadItem() need not do any work at all and will not even invoke
* the callback handlers. So, before invoking this method, check that
* the item has not already been loaded.
*/
loadItem(keywordArgs: LoadItemArgs<T>): T;
/**
* Given a query and set of defined options, such as a start and count of items to return,
* this method executes the query and makes the results available as data items.
* The format and expectations of stores is that they operate in a generally asynchronous
* manner, therefore callbacks are always used to return items located by the fetch parameters.
*/
fetch(keywordArgs: FetchArgs<T>): Request;
/**
* The getFeatures() method returns an simple keyword values object
* that specifies what interface features the datastore implements.
* A simple CsvStore may be read-only, and the only feature it
* implements will be the 'dojo/data/api/Read' interface, so the
* getFeatures() method will return an object like this one:
* {'dojo.data.api.Read': true}.
* A more sophisticated datastore might implement a variety of
* interface features, like 'dojo.data.api.Read', 'dojo/data/api/Write',
* 'dojo.data.api.Identity', and 'dojo/data/api/Attribution'.
*/
getFeatures(): Features;
/**
* The close() method is intended for instructing the store to 'close' out
* any information associated with a particular request.
*/
close(request?: Request): void;
/**
* Method to inspect the item and return a user-readable 'label' for the item
* that provides a general/adequate description of what the item is.
*/
getLabel(item: T): string;
/**
* Method to inspect the item and return an array of what attributes of the item were used
* to generate its label, if any.
*/
getLabelAttributes(item: T): string[];
}
interface ReadConstructor {
new <T extends Item>(): Read<T>;
prototype: Read<Item>;
}
/* dojo/data/api/Request */
interface Request {
/**
* This class defines out the semantics of what a 'Request' object looks like
* when returned from a fetch() method. In general, a request object is
* nothing more than the original keywordArgs from fetch with an abort function
* attached to it to allow users to abort a particular request if they so choose.
* No other functions are required on a general Request object return. That does not
* inhibit other store implementations from adding extensions to it, of course.
* This is an abstract API that data provider implementations conform to.
* This file defines methods signatures and intentionally leaves all the
* methods unimplemented.
* For more details on fetch, see dojo/data/api/Read.fetch().
*/
abort(): void;
}
interface RequestConstructor {
new (): Request;
prototype: Request;
}
/* dojo/data/api/Write */
interface Features {
'dojo.data.api.Write': boolean;
}
interface SaveKeywordArgs {
onComplete?: () => void;
onError?: (error: Error) => void;
scope?: Object;
}
interface Write<T extends Item> {
/**
* See dojo/data/api/Read.getFeatures()
*/
getFeatures(): Features;
/**
* Returns a newly created item. Sets the attributes of the new
* item based on the *keywordArgs* provided. In general, the attribute
* names in the keywords become the attributes in the new item and as for
* the attribute values in keywordArgs, they become the values of the attributes
* in the new item. In addition, for stores that support hierarchical item
* creation, an optional second parameter is accepted that defines what item is the parent
* of the new item and what attribute of that item should the new item be assigned to.
* In general, this will assume that the attribute targeted is multi-valued and a new item
* is appended onto the list of values for that attribute.
*/
newItem(keywordArgs: T, parentInfo?: ParentInfo<T>): T;
/**
* Deletes an item from the store.
*/
deleteItem(item: T): boolean;
/**
* Sets the value of an attribute on an item.
* Replaces any previous value or values.
*/
setValue(item: T, attribute: string, value: any): boolean;
/**
* Adds each value in the *values* array as a value of the given
* attribute on the given item.
* Replaces any previous value or values.
* Calling store.setValues(x, y, []) (with *values* as an empty array) has
* the same effect as calling store.unsetAttribute(x, y).
*/
setValues(item: T, attribute: string, values: any[]): boolean;
/**
* Deletes all the values of an attribute on an item.
*/
unsetAttribute(item: T, attribute: string): boolean;
/**
* Saves to the server all the changes that have been made locally.
* The save operation may take some time and is generally performed
* in an asynchronous fashion. The outcome of the save action is
* is passed into the set of supported callbacks for the save.
*/
save(keywordArgs: SaveKeywordArgs): void;
/**
* Discards any unsaved changes.
*/
revert(): boolean;
/**
* Given an item, isDirty() returns true if the item has been modified
* since the last save(). If isDirty() is called with no *item* argument,
* then this function returns true if any item has been modified since
* the last save().
*/
isDirty(item?: T): boolean;
}
interface WriteConstructor {
new <T>(): Write<T>;
prototype: Write<any>;
}
}
namespace util {
/* dojo/data/util/filter */
interface Filter {
/**
* Helper function to convert a simple pattern to a regular expression for matching.
*/
patternToRegExp(pattern: string, ignoreCase?: boolean): RegExp;
}
/* dojo/data/util/simpleFetch */
interface SimpleFetch {
/**
* The error handler when there is an error fetching items. This function should not be called
* directly and is used by simpleFetch.fetch().
*/
errorHandler(errorData: Error, requestObject: api.Request): void;
/**
* The handler when items are successfully fetched. This function should not be called directly
* and is used by simpleFetch.fetch().
*/
fetchHandler<T extends api.Item>(items: T[], requestObject: api.Request): void;
/**
* The simpleFetch mixin is designed to serve as a set of function(s) that can
* be mixed into other datastore implementations to accelerate their development.
*/
fetch(request?: api.Request): api.Request;
}
/* dojo/data/util/sorter */
interface SortFunction<T> {
(a: T, b: T): number;
}
interface Sorter {
/**
* Basic comparison function that compares if an item is greater or less than another item
*/
basicComparator: SortFunction<any>;
/**
* Helper function to generate the sorting function based off the list of sort attributes.
*/
createSortFunction<T>(attributes: api.SortArg[], store: api.Read<T>): SortFunction<T>;
}
}
/* dojo/data/ItemFileReadStore */
interface ItemFileReadStoreData<T extends api.Item> {
items: T[];
identifier?: string;
}
interface ItemConstructor<V, T> {
new (value: V): T;
prototype: T;
}
interface ItemConstructorObject<V, T> {
type: GenericConstructor<T>;
deserialize: (value: V) => T;
}
interface ItemFileReadStoreTypeMap {
[type: string]: ItemConstructor<any, any> | ItemConstructorObject<any, any>;
}
interface ItemFileReadStoreArgs<T extends api.Item> {
url?: string;
data?: ItemFileReadStoreData<T>;
typeMap?: ItemFileReadStoreTypeMap;
}
interface FindCallback<T extends api.Item> {
(items: T[], requestArgs: api.Request): void;
}
interface ItemFileReadStore<T extends api.Item> extends Evented, util.SimpleFetch {
/**
* Parameter to allow users to specify if a close call should force a reload or not.
* By default, it retains the old behavior of not clearing if close is called. But
* if set true, the store will be reset to default state. Note that by doing this,
* all item handles will become invalid and a new fetch must be issued.
*/
clearOnClose: boolean;
/**
* Parameter to allow specifying if preventCache should be passed to the xhrGet call or not when loading data from a url.
* Note this does not mean the store calls the server on each fetch, only that the data load has preventCache set as an option.
* Added for tracker: #6072
*/
urlPreventCache: boolean;
/**
* Parameter for specifying that it is OK for the xhrGet call to fail silently.
*/
failOk: boolean;
/**
* Parameter to indicate to process data from the url as hierarchical
* (data items can contain other data items in js form). Default is true
* for backwards compatibility. False means only root items are processed
* as items, all child objects outside of type-mapped objects and those in
* specific reference format, are left straight JS data objects.
*/
hierarchical: boolean;
/**
* This function tests whether the item passed in is indeed an item in the store.
*/
_assertIsItem(item: any): void;
/**
* This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.
*/
_assertIsAttribute(attribute: string): void;
/**
* See dojo/data/api/Read.getValue()
*/
getValue<V>(item: T, attribute: string, value?: V): V;
/**
* See dojo/data/api/Read.getValues()
*/
getValues<V>(item: T, attribute: string): V[];
/**
* See dojo/data/api/Read.getAttributes()
*/
getAttributes(item: T): string[];
/**
* See dojo/data/api/Read.hasAttribute()
*/
hasAttribute(item: T, attribute: string): boolean;
/**
* See dojo/data/api/Read.containsValue()
*/
containsValue(item: T, attribute: string, value: any): boolean;
/**
* Internal function for looking at the values contained by the item.
*/
_containsValue(item: T, attribute: string, value: any, regexp?: RegExp): boolean;
/**
* See dojo/data/api/Read.isItem()
*/
isItem(something: any): something is T;
/**
* See dojo/data/api/Read.isItemLoaded()
*/
isItemLoaded(something: any): boolean;
/**
* See dojo/data/api/Read.loadItem()
*/
loadItem(keywordArgs: api.LoadItemArgs<T>): void;
/**
* See dojo/data/api/Read.getFeatures()
*/
getFeatures(): api.Features;
/**
* See dojo/data/api/Read.getLabel()
*/
getLabel(item: T): string;
/**
* See dojo/data/api/Read.getLabelAttributes()
*/
getLabelAttributes(item: T): string[];
/**
* This method handles the basic filtering needs for ItemFile* based stores.
*/
filter(requestArgs: api.Request, arrayOfItems: T[], findCallback: FindCallback<T>): void;
/**
* See dojo/data/util.simpleFetch.fetch()
*/
_fetchItems(keywordArgs: api.FetchArgs<T>, findeCallback: FindCallback<T>): void;
/**
* Internal function to execute delayed request in the store.
*/
_handleQueuedFetches(): void;
/**
* Internal function to determine which list of items to search over.
*/
_getItemsArray(queryOptions?: { deep?: boolean }): T[];
/**
* See dojo/data/api/Read.close()
*/
close(request?: api.Request): void;
/**
* Function to parse the loaded data into item format and build the internal items array.
*/
_getItemsFromLoadedData(dataObject: Object): void;
/**
* Method to add an reference map entry for an item and attribute.
*/
_addReferenceToMap(refItem: T, parentItem: T, attribute: string): void;
/**
* See dojo/data/api/Identity.getIdentity()
*/
getIdentity(item: T): Object | string | number;
/**
* See dojo/data/api/Identity.fetchItemByIdentity()
*/
fetchItemByIdentity(keywordArgs: api.FetchByIdentityArgs<T>): T;
/**
* Internal function to look an item up by its identity map.
*/
_getItemByIdentity(identity: Object): T;
/**
* See dojo/data/api/Identity.getIdentityAttributes()
*/
getIdentityAttributes(item: T): string[];
/**
* Internal function to force a load of the store if it hasn't occurred yet. This is required
* for specific functions to work properly.
*/
_forceLoad(): void;
}
interface ItemFileReadStoreConstructor {
new <T extends api.Item>(keywordParameters: ItemFileReadStoreArgs<T>): ItemFileReadStore<T>;
prototype: ItemFileReadStore<api.Item>;
}
/* dojo/data/ItemFileWriteStore */
interface ItemFileWriteStore<T extends api.Item> extends ItemFileReadStore<T> {
referenceIntegrity: boolean;
_assert(condition: boolean): void;
_getIdentifierAttribute(): boolean;
/**
* See dojo/data/api/Write.newItem()
*/
newItem(keywordArgs: T, parentInfo?: api.ParentInfo<T>): T;
_removeArrayElement(array: any[], element: any): boolean;
/**
* See dojo/data/api/Write.deleteItem()
*/
deleteItem(item: T): boolean;
/**
* See dojo/data/api/Write.set()
*/
setValue(item: T, attribute: string, value: any): boolean;
/**
* See dojo/data/api/Write.setValues()
*/
setValues(item: T, attribute: string, values: any[]): boolean;
/**
* See dojo/data/api/Write.unsetAttribute()
*/
unsetAttribute(item: T, attribute: string): boolean;
_setValueOrValues(item: T, attribute: any, newValueOrValues: any, callOnSet?: boolean): boolean;
/**
* Method to remove an reference map entry for an item and attribute.
*/
_removeReferenceFromMap(refItem: T, parentItem: T, attribute: string): void;
/**
* Function to dump the reverse reference map of all items in the store for debug purposes.
*/
_dumpReferenceMap(): void;
_getValueOrValues(item: T, attribute: string): any;
_flatten(value: any): any;
/**
* Generate a string that can be saved to a file.
* The result should look similar to:
* http://trac.dojotoolkit.org/browser/dojo/trunk/tests/data/countries.json
*/
_getNewFileContentString(): string;
/**
* Function to determine if an array or object has no properties or values.
*/
_isEmpty(something: any): boolean;
/**
* See dojo/data/api/Write.save()
*/
save(keywordArgs: api.SaveKeywordArgs): void;
/**
* See dojo/data/api/Write.revert()
*/
revert(): boolean;
/**
* See dojo/data/api/Write.isDirty()
*/
isDirty(item: T): boolean;
/**
* See dojo/data/api/Notification.onSet()
*/
onSet(item: T, attribute: string, oldValue: any, newValue: any): void;
/**
* See dojo/data/api/Notification.onNew()
*/
onNew(item: T, parentInfo?: api.ParentInfo<T>): void;
/**
* See dojo/data/api/Notification.onDelete()
*/
onDelete(deletedItem: T): void;
}
interface ItemFileWriteStoreConstructor {
new <T extends api.Item>(keywordParameters: ItemFileReadStoreArgs<T>): ItemFileWriteStore<T>;
prototype: ItemFileWriteStore<api.Item>;
}
/* dojo/data/ObjectStore */
/* TODO: Replace with Store API when Typed */
interface Store { }
interface ObjectStoreOptions {
objectStore?: Store;
labelAttribute?: string;
labelProperty?: string;
}
interface ObjectStoreSaveArgs {
/**
* This will cause the save to commit the dirty data for all
* ObjectStores as a single transaction.
*/
global?: boolean;
/**
* This will cause the changes to be reverted if there is an
* error on the save. By default a revert is executed unless
* a value of false is provide for this parameter.
*/
revertOnError?: boolean;
/**
* Called when an error occurs in the commit
*/
onError(e: Error): void;
/**
* Called when an the save/commit is completed
*/
onComplete(actions: any[]): void;
scope?: Object;
}
interface ObjectStore<T extends api.Item> extends Evented {
objectStore: Store;
labelProperty: string;
/**
* Gets the value of an item's 'property'
*/
getValue(item: T, property: string, defaultValue?: any): any;
/**
* Gets the value of an item's 'property' and returns
* it. If this value is an array it is just returned,
* if not, the value is added to an array and that is returned.
*/
getValues(item: T, property: string): any[];
/**
* Gets the available attributes of an item's 'property' and returns
* it as an array.
*/
getAttributes(item: T): string[];
/**
* Checks to see if item has attribute
*/
hasAttribute(item: T, attribute: string): boolean;
/**
* Checks to see if 'item' has 'value' at 'attribute'
*/
containsValue(item: T, attribute: string, value: any): boolean;
/**
* Checks to see if the argument is an item
*/
isItem(item: any): item is T;
/**
* Checks to see if the item is loaded.
*/
isItemLoaded(item: any): boolean;
/**
* Loads an item and calls the callback handler. Note, that this will call the callback
* handler even if the item is loaded. Consequently, you can use loadItem to ensure
* that an item is loaded is situations when the item may or may not be loaded yet.
* If you access a value directly through property access, you can use this to load
* a lazy value as well (doesn't need to be an item).
*/
loadItem(keywordArgs: api.LoadItemArgs<T>): T;
/**
* See dojo/data/api/Read.close()
*/
close(request?: api.Request): void;
/**
* See dojo/data/api/Read.fetch()
*/
fetch(keywordArgs: api.FetchArgs<T>): api.Request;
/**
* return the store feature set
*/
getFeatures(): api.Features;
/**
* See dojo/data/api/Read.getLabel()
*/
getLabel(item: T): string;
/**
* See dojo/data/api/Read.getLabelAttributes()
*/
getLabelAttributes(item: T): string[];
/**
* returns the identity of the given item
* See dojo/data/api/Read.getIdentity()
*/
getIdentity(item: T): Object | string | number;
/**
* returns the attributes which are used to make up the
* identity of an item. Basically returns this.objectStore.idProperty
* See dojo/data/api/Read.getIdentityAttributes()
*/
getIdentityAttributes(item: T): string[];
/**
* fetch an item by its identity, by looking in our index of what we have loaded
*/
fetchItemByIdentity(keywordArgs: api.FetchByIdentityArgs<T>): T;
/**
* adds a new item to the store at the specified point.
* Takes two parameters, data, and options.
*/
newItem(keywordArgs: T, parentInfo?: api.ParentInfo<T>): T;
/**
* deletes item and any references to that item from the store.
*/
deleteItem(item: T): void;
/**
* sets 'attribute' on 'item' to 'value'
* See dojo/data/api/Write.setValue()
*/
setValue(item: T, attribute: string, value: any): boolean;
/**
* sets 'attribute' on 'item' to 'value' value
* must be an array.
* See dojo/data/api/Write.setValues()
*/
setValues(item: T, attribute: string, values: any[]): boolean;
/**
* unsets 'attribute' on 'item'
* See dojo/data/api/Write.unsetAttribute()
*/
unsetAttribute(item: T, attribute: string): boolean;
/**
* adds an object to the list of dirty objects. This object
* contains a reference to the object itself as well as a
* cloned and trimmed version of old object for use with
* revert.
*/
changing(object: T, _deleting: boolean): void;
/**
* Saves the dirty data using object store provider. See dojo/data/api/Write for API.
*/
save(kwArgs: ObjectStoreSaveArgs): void;
/**
* returns any modified data to its original state prior to a save();
*/
revert(): void;
/**
* returns true if the item is marked as dirty or true if there are any dirty items
*/
isDirty(item: T): boolean;
/**
* See dojo/data/api/Notification.onSet()
*/
onSet(item: T, attribute: string, oldValue: any, newValue: any): void;
/**
* See dojo/data/api/Notification.onNew()
*/
onNew(item: T, parentInfo?: api.ParentInfo<T>): void;
/**
* See dojo/data/api/Notification.onDelete()
*/
onDelete(deletedItem: T): void;
/**
* Called when a fetch occurs
*/
onFetch(results: any): void;
}
/**
* A Dojo Data implementation that wraps Dojo object stores for backwards
* compatibility.
*/
interface ObjectStoreConstructor {
new <T extends api.Item>(options: ObjectStoreOptions): ObjectStore<T>;
prototype: ObjectStore<api.Item>;
}
}
}