|
|
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>;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
