VersionStore

A store that holds the list of saved project versions (snapshots), managed by the Versions feature. Each record is a VersionModel containing a complete snapshot of the project data at the time of capture along with a reference to the changelog entries recorded since the previous version.

This store works together with the ChangeLogStore to provide full version history and change tracking for the project. You can provide a custom subclass of VersionModel using the versionModelClass config.

const schedulerPro = new SchedulerPro({
    features : {
        versions : true
    }
});

// Access the version store via the Versions feature
const { versionStore } = schedulerPro.features.versions;

// List saved versions
versionStore.forEach(version => {
    console.log(version.name, version.savedAt);
});

Configs

Configs are options you supply in a configuration object when creating an instance of this class

autoCommit : Booleanfalse
StoreCRUD

Commit changes automatically

Has a corresponding runtime autoCommit property.
autoLoad : Boolean
Store

For a non-AjaxStore, the autoLoad config will only take effect if the store is configured as lazyLoad, remoteSort, remoteFilter or remotePaging. In these cases, it will immediately after creation, perform a request by calling the requestData function.
data : Object[]/Model[]

NON-LAZY-LOAD
Store
Raw data to load initially.

Expects an array of JavaScript objects, with properties matching store's fields (defined on its model or in the fields config).
```
const store = new Store({
    data : [
        { id : 1, name : 'Linda', city : 'NY' },
        { id : 2, name : 'Olivia', city : 'Paris' },
        ...
    ]
});
```
Has a corresponding runtime data property.
fields : (String|DataFieldConfig|DataField)[]
Store
An array of field definitions used to create a Model (modelClass) subclass. Optional. If the Model already has fields defined, these fields will extend those.
```
const store = new Store({
    fields : ['name', 'city', 'company'],
    data   : [
        { id : 1, name : 'Mark', city : 'London', company : 'Cool inc' },
        ...
    ]
});
```
See Model for more info on defining fields, changing data source and mapping fields to nested objects.

Note that pre-created record instances supplied to the store are kept as is and thus these fields will not apply to them.
groupers : Grouper[]

NON-LAZY-LOAD
StoreGroup

Initial groupers, specify to have store grouped automatically after initially setting data

Has a corresponding runtime groupers property.
id : String/Number
Store

Store's unique identifier. When set the store is added to a store map accessible through Store.getStore(id).

Has a corresponding runtime id property.

listeners : Object

Events

The listener set for this object.

An object whose property names are the names of events to handle, or options which modifiy how the handlers are called.

See addListener for details about the options.

Listeners can be specified in target class config and they will be merged with any listeners specified in the instantiation config. Class listeners will be fired first:

class MyStore extends Store({
    static configurable = {
        listeners : {
            myCustomEvent() {
            },
            load : {
                prio : 10000,
                fn() { // this load listener handles things first }
            }
        }
    };
});

let store = new MyStore({
  listeners: {
    load: () => { // This load listener runs after the class's },
    ...
  }
});

Handlers as function name

Object event handlers may be specified as a function name. If a string is specified, it is the name of the function in the thisObj object.

If the string begins with up., this object's ownership hierarchy (if present) is scanned for an object which implements that function name:

new Popup({
    tbar : {
        items : {
            myCombo : {
                type      : 'combo',
                editable  : false,
                label     : 'Type',
                listeners : {
                    // Look in owner chain for this function name
                    change : 'up.onFilterChange'
                },
                items     : [
                    'Event',
                    'Task',
                    'Appointment'
                ]
            }
        }
    },
    items : {
        ...
    },
    onFilterChange({ value }) {
        // Handle event type selection here
    }
});

modelClass : Model

Store

Class used to represent records in the store, should be a subclass of Model. Only applies when supplying data to the store (load, add), any supplied record instances are kept as is.

class MyModel extends Model {
    static get fields() {
        return [
            'name',
            'city',
            'company'
        ]
    }
}

const store = new Store({
    modelClass : MyModel,
    data : [
        { id : 1, name : 'Mark', city : 'London', company : 'Cool inc' },
        ...
    ]
});

Has a corresponding runtime modelClass property.

requestData : Function

ASYNC
Store
In a non-AjaxStore, configured with lazyLoad, remoteSort, remoteFilter or remotePaging, the function provided here is called when the Store needs new data, which will happen:
- for lazyLoad, when a record that has not yet been loaded is requested.
- for remoteSort, on a sort operation.
- for remoteFilter, on a filter operation.
- for remotePaging, when current page is changed.
When implementing this, it is expected that what is returned is an object with a data property containing the records requested. What is requested will be specified in the params object, which will differ depending on the source of the request.

For lazyLoad, the params object will contain a startIndex and a count param. It is expected for the implementation of this function to provide a data property containing the number of records specified in the count param starting from the specified startIndex.
```
class MyStore extends Store {
   async requestData({startIndex, count}){
      const response = await getData(startIndex, count);
      return {
         data : response.records,
         total : response.totalRecordCount
      }
   }
}
```
For remotePaging, the params object will contain a page and a pageSize param. It is expected for the implementation of this function to provide a data property containing the number of records specified in the pageSize param starting from the specified page.
```
class MyStore extends Store {
   requestData({page, pageSize}){
      const start = (page - 1) * pageSize;
      const data = allRecords.splice(start, start + pageSize);

      return {
         data,
         total : allRecords.length
      }
   }
}
```
For lazyLoad it is recommended, and for remotePaging it is required, to include a total property which reflects the total amount of records available to load. If the total property is omitted (when lazyLoad), certain features and functions are disabled:
- The component (Grid for example) is not aware of the total number of records, which will make the scrollbar's thumb change size and position when new records are loaded.
- The store don't know when to stop requesting new records. The total property will be set to the index of the last record loaded after requestData returns with fewer records than requested.
If remoteSort is active, the params object will contain a sorters param, containing a number of sorter objects.The sorter objects will look like this:
```
{
    "field": "name",
    "ascending": true
}
```
If remoteFilter is active, the params object will contain a filters param, containing a number of filters objects. The filter objects will look like this:
```
{
    "field": "country",
    "operator": "=",
    "value": "sweden",
    "caseSensitive": false
}
```
The Base implementation of this function does nothing, you need to create your own subclass with an implementation.

Configuration parameter to pass a function to be used as requestData in non-AjaxStore.
Parameters
- params : LazyLoadRequestParams/PagingRequestParams
  
  Object containing info of which records is requested
Returns

DataLoadRequestResponse
sorters : Sorter[]/String[]
StoreSort
Initial sorters, format is:
```
{ sorters : [{ field: 'name', ascending: false }, ...] }
// or
{ sorters : ['name', ...] }
```
Has a corresponding runtime sorters property.
syncDataOnLoad : Boolean/SyncDataOnLoadOptionsfalse

NON-LAZY-LOAD
StoreSync
Configure with true to sync loaded data instead of replacing existing with a new dataset.

By default (or when configured with false) assigning to store.data replaces the entire dataset with a new one, creating all new records:
```
store.data = [ { id : 1, name : 'Saitama' } ];

const first = store.first;

store.data = [ { id : 1, name : 'One-Punch man' } ];

// store.first !== first;
```
When configured with true the new dataset is instead synced against the old, figuring out what was added, removed and updated:
```
store.data = [ { id : 1, name : 'Saitama' } ];

const first = store.first;

store.data = [ { id : 1, name : 'One-Punch man' } ];

// store.first === first;
```
After the sync, any configured sorters, groupers and filters will be reapplied.

Threshold

The sync operation has a configurable threshold, above which the operation will be treated as a batch/refresh and only trigger a single refresh event. If threshold is not reached, individual events will be triggered (single add, remove and possible multiple update). To enable the threshold, supply a config object with a threshold property instead of true:
```
const store = new Store({
    syncDataOnLoad : {
        threshold : '20%'
    }
});
```
threshold accepts numbers or strings. A numeric threshold means number of affected records, while a string is used as a percentage of the whole dataset (appending % is optional). By default no threshold is used.

Missing fields

The value of any field not supplied in the new dataset is by default kept as is (if record is not removed by the sync). This behaviour is configurable, by setting keepMissingValues : false in a config object it will reset any unspecified field back to their default values:
```
const store = new Store({
    syncDataOnLoad : {
        keepMissingValues : false
    }
});
```
Considering the following sync operation:
```
// Existing data
{ id : 1, name : 'Saitama', powerLevel : 100 }
// Sync data
{ id : 1, name : 'One-Punch Man' }
```
The result would by default (or when explicitly configured with true) be:
```
{ id : 1, name : 'One-Punch Man', powerLevel : 100 }
```
If configured with keepMissingValues : false it would instead be:
```
{ id : 1, name : 'One-Punch Man' }
```
Never enable syncDataOnLoad on a chained store, it will create an infinite loop when it is populated from the main store (the main store can use the setting)
allowNoId : Booleantrue
Store

Specify false to prevent loading records without ids, a good practice to enforce when syncing with a backend.

By default, Store allows loading records without ids, in which case a generated id will be assigned.
applyChangesetFilterSortTarget : 'changes'/'none'changes
StoreChanges
Specifies target to filter and sort after applying changeset:
- 'changes' - apply sort and filter to changeset only (see more below)
- 'none' - do not apply sort and filter
changes behavior

If the store has filters in effect when the changeset is applied, the following rules will determine how the filtered values are affected:
- Among added records, only those that match the filter will be included in the filtered set
- Among updated records, those that did not previously match the filter but now do will be added to the filtered set, and those that did match but no longer do will also remain in the filtered set. This means that new records may appear in the filtered set as a result of applyChanges, but records will not disappear until filters are re-applied.
Does not apply if the store is remotely filtered.

Has a corresponding runtime applyChangesetFilterSortTarget property.
ignoreRemoteChangesInSTM : Booleanfalse
StoreStm

Set to false to not record transaction during applyChangeset call

Has a corresponding runtime ignoreRemoteChangesInSTM property.
preventSubClassingModel : Booleanfalse

private
Store

Prevent dynamically subclassing the modelClass. It does so by default to not pollute it when exposing properties. Should rarely need to be used.
startGroupsCollapsed : Booleanfalse
StoreGroup

To have all groups initially loaded start collapsed, configure this as true.

Note that this only affects the initial load of the store. Subsequent reloads maintain current group state where possible.
stm : StateTrackingManager
StoreStm

Reference to STM manager
storage : Collection/CollectionConfig
Store

A Collection, or Collection config object to use to contain this Store's constituent records.
storeClass : Class
Store
Store class to use when creating the store when it is a part of a CrudManager.
```
crudManager : {
     eventStore {
         storeClass : MyEventStore
     }
}
```
useLocaleSort : Boolean/String/Objectfalse
StoreSort
Use localeCompare() when sorting, which lets the browser sort in a locale specific order. Set to true, a locale string or a locale config to enable.

Enabling this has big negative impact on sorting performance. For more info on localeCompare(), see MDN.

Examples:
```
const store = new Store({
    // Swedish sorting
    useLocaleSort : 'sv-SE'
});

const store = new Store({
    // Swedish sorting with custom casing order
    useLocaleSort : {
        locale    : 'sv-SE',
        caseFirst : 'upper'
    }
});
```
Can also be configured on a per-sorter basis:
```
store.sort({ field: 'name', useLocaleSort : 'sv-SE' });
```
useRawData : Boolean/Object

NON-LAZY-LOAD
Store
Retools the loaded data objects instead of making shallow copies of them. This increases performance but pollutes the incoming data.

This setting is off by default, but is turned on automatically unless explicitly configured when data is loaded using an AjaxStore (configured with a readUrl) or a CrudManager (configured to load data remotely).
```
// No duplicate id checking, no type conversions
new Store({ useRawData : true });
```
Also allows disabling certain steps in data loading, to further improved performance. Either accepts an object with the params described below or true which enables disableDuplicateIdCheck.
```
new Store({
  // No type conversions only
  useRawData : {
    disableTypeConversion : true
  }
});
```
Note that if the first object in the incoming data is determined to be un-extensible (~immutable), the entire incoming dataset will be cloned.

Also note that since incoming data objects gets polluted with this setting on, reusing the same data objects elsewhere might lead to unexpected behavior.

When binding to data in frameworks with this setting enabled, the same principles as for framework state applies - an object in the incoming data must be replaced instead of mutated for a change to be detected. See for example React's explanation here
Parameters
- disableDuplicateIdCheck : Boolean
  
  Data must not contain duplicate ids, check is bypassed.
- disableDefaultValue : Boolean
  
  Default values will not be applied to record fields.
- disableTypeConversion : Boolean
  
  No type conversions will be performed on record data. Incoming data must be in the correct format expected by each field, for example dates must be Date objects.
chainFilters : Booleanfalse
StoreChained

If true, chained stores will apply filters from the master store. Filters flagged with ignoreForChain will be ignored.

Only applies to chained stores
chainedFields : String[]

NON-LAZY-LOAD
StoreChained

Array of field names that should trigger filtering of chained store when the fields are updated.

Only applies to chained stores
chainedFilterFn : Function

NON-LAZY-LOAD
StoreChained
Function used to filter records in the masterStore into a chained store. If not provided, all records from the masterStore will be included in the chained store. Return true to include the passed record, or a false to exclude it.

Only applies to chained stores
Parameters
- record : Model
  Record
Returns

Boolean
doRelayToMaster : String[]

NON-LAZY-LOAD
StoreChained

Method names calls to which should be relayed to master store.

Only applies to chained stores
dontRelayToMaster : String

NON-LAZY-LOAD
StoreChained

Method names calls to which shouldn't be relayed to master store.

Only applies to chained stores
excludeCollapsedRecords : Booleantrue

NON-LAZY-LOAD
StoreChained

If true, collapsed records in original tree will be excluded from the chained store.

Only applies to chained stores, and not when chaining using chainTree()
ignoreLinkRecords : Booleanfalse

NON-LAZY-LOAD
StoreChained

Set to true to prevent including links (when grouping by array field)

Only applies to chained stores
masterStore : Store

NON-LAZY-LOAD
StoreChained

Master store that a chained store gets its records from.

Only applies to chained stores
syncOrder : Booleanfalse
StoreChained
If true, changing the order of records in a flat chained store (for example by using the RowReorder feature in a Grid-based widget) will also change the order of records in the master store.

Note that this config does not apply to chained tree stores (created using chainTree). Chained tree stores always sync the order of their records with the master store.

Example usage:
```
store.chain(record => record.percent < 10, null, {
  syncOrder : true
});
```
The predictability of the outcome depends on the order of the records in both stores, and if the subset of records in the chained store is contiguous. For example, if the master store has records A B C D E, and the chained store has E C A, it will be difficult for users to predict the outcome of moving E to between C A.
syncSort : Booleantrue
StoreChained

If true, chained stores will be sorted when the master store is sorted. Note that this replaces any existing sorters defined on the chained store.

Only applies to chained stores
catchEventHandlerExceptions : Booleanfalse

ADVANCED
Events

By default, if an event handler throws an exception, the error propagates up the stack and the application state is undefined. Code which follows the event handler will not be executed.

Set this to true to catch exceptions thrown by this object's event handlers and continue processing the event. The exception will be rethrown on a zero millisecond timeout, so it will not destroy the stack.

Has a corresponding runtime catchEventHandlerExceptions property.
internalListeners : Object

internal
Events

Internal listeners, that cannot be removed by the user.

filters : CollectionFilterConfig/CollectionFilterConfig

StoreFilter

Specify one or more CollectionFilter config objects to apply initially.

For example:

 // Configure the store to filter in clients over the age of 30
 new Store({
     ...,
     filters : [{
         property : 'age',
         value    : 30,
         operator : '>'
     }],
     ...
 })

or:

 // Configure the store to filter based on a complex operation
 new Store({
     ...,
     filters : [{
         filterBy(record) {
             // Return true or false for filtering in or out
             return shouldClientBeVisible(record);
         }
     }],
     ...
 })

Has a corresponding runtime filters property.

reapplyFilterOnAdd : Booleanfalse
StoreFilter

Specify true to reapply filters when a record is added to or moved within the store. This includes tree node operations like indent/outdent in Gantt, or any move operation that changes a node's parent.
reapplyFilterOnUpdate : Boolean/Object
StoreFilter
Specify true to reapply filters when a record is updated in the store. You can also provide an array of field names, to only re-filter when certain data fields are updated.
- fields : String[]
  Fields
reapplySortersOnUpdate : Boolean/Object
StoreSort
Specify true to reapply sorting when a record is updated in the store. You can also provide an array of field names, to only trigger sort when certain data fields are updated.

If the app processes many records or many record fields in a loop or similar, be sure to temporarily disable this setting. Otherwise, each change will trigger a sort, which will make the processing slow
- fields : String[]
  
  Fields that reapply sorting when updated
Has a corresponding runtime reapplySortersOnUpdate property.
remoteFilter : Boolean
StoreFilter

Set this to true to activate remote filtering in this Store. This makes it possible to use the built-in filtering features of the Store and corresponding UI functionality, without using local data.

For a non-AjaxStore, data will be requested by the Store by calling a by the app implemented requestData function. Data can also be provided by listening to the requestData event, and updating the data property with new data.

For AjaxStore, data will be loaded via the configured readUrl.

bubbleEvents : Object

Events

An object where property names with a truthy value indicate which events should bubble up the ownership hierarchy when triggered.

const container = new Container({
    items : [
       { type : 'text', bubbleEvents : { change : true }}
    ],

    listeners : {
        change() {
            // Will catch change event from the text field
        }
    }
});

callOnFunctions : Booleanfalse
Events
Set to true to call onXXX method names (e.g. onShow, onClick), as an easy way to listen for events.
```
const container = new Container({
    callOnFunctions : true

    onHide() {
         // Do something when the 'hide' event is fired
    }
});
```
Has a corresponding runtime callOnFunctions property.
pageParamName : String

NON-LAZY-LOAD
StorePaging

The name of the parameter to use when requesting pages of data using the zero based index of the required page's starting record.
pageSize : Number50

NON-LAZY-LOAD
StorePaging

When the Store is paged by configuring remotePaging, this value will be included in the load requests.

Note: Setting pageSize at runtime will automatically reload the page.

Has a corresponding runtime pageSize property.
pageSizeParamName : StringpageSize

NON-LAZY-LOAD
StorePaging

The name of the parameter to use when requesting pages of data, representing the configured pageSize value.
pageStartParamName : String

NON-LAZY-LOAD
StorePaging

The name of the parameter to use when requesting pages of data using the one based page number required.
remotePaging : Boolean
StorePaging

Set this to true to activate remote paging in this Store. Makes it possible to use the loadPage, nextPage, and previousPage functions. Or add the PagingToolbar to control what page to load.

For a non-AjaxStore, data will be requested by the Store by calling a by the app implemented requestData function. Data can also be provided by listening to the requestData event, and updating the data property with new data.
createRecord : Function
Store
Creates a model instance, used internally when data is set/added. Provide this method for your own custom conversion from data to record.
Parameters
- data : *
  
  Json data
- skipExpose : Booleanfalse
  
  Supply true when batch setting to not expose properties multiple times
Returns

Model
filterParamName : String
StoreFilter

The name of the parameter to use to pass any filters when loading data remotely.

Note: When this is set, filters must be defined using a field name, an operator and a value to compare, not a comparison function.
reapplySortersOnAdd : Booleanfalse
StoreSort

Specify true to sort this store after records are added.
remoteSort : Boolean
StoreSort

Set this to true to activate remote sorting in this Store. This makes it possible to use the built-in sorting features of the Store and corresponding UI functionality, without using local data.

For a non-AjaxStore, data will be requested by the Store by calling a by the app implemented requestData function. Data can also be provided by listening to the requestData event, and updating the data property with new data.

For AjaxStore, data will be loaded via the configured readUrl.
sortParamName : String
StoreSort

The name of the parameter to use to pass any sorters when loading data remotely.

Note: When this is set, sorters must be defined using a field name and an ascending flag, not a sort function.
verifyNoGeneratedIds : Booleantrue
Store

Verify that loaded data does not contain any generated ids. If it does, a warning is logged on console.

Set this to false to disable the check and give a very minor performance boost.

Has a corresponding runtime verifyNoGeneratedIds property.
useSparseIndex : Booleanfalse
StoreSparseIndex

Enable sparse index handling. When enabled, the store's model will be augmented with a sparseIndex field (unless it already exists) which will be automatically managed by the store. When adding or inserting records into the store, sparse indexes will be generated for those records. When moving records, their sparse index will be updated with a fractional number. They will be used to sort records when no other sorter is defined on the store.

Sparse indexes are a tree-defining property. They will also be used to determine the order of records when persisting the store's data. When using sparse indexes in a tree store, the store's parentId will also be made persistent to allow reconstruction of the tree structure when loading data.

When using sparse indexes, the other tree-defining properties parentIndex and orderedParentIndex will no longer be persistent. Their values will still be updated when items are added, removed, or re-ordered, but they won't be marked as dirty and won't be included when persisting the store's data. If it is necessary to persist these fields, use hierarchyModificationDataToWrite.
reorderOnSync : Boolean

private
StoreSync

When using syncDataOnLoad and the store is neither sorted nor grouped, the order of the incoming dataset is respected. This has a cost, since records in the store might have to be moved around.

For stores where the order is not important, this behavior can be disabled to improve performance by configuring reorderOnSync as false.
shouldSyncDataset : Function

private
StoreSync
Experimental hook to allow app to determine if sync should be performed, and/or for which records.
Parameters
- options : Object
  Options
- data : Object[]
  
  New dataset, an array of incoming data objects
- store : Store
  
  This store
- records : Model[]
  
  Records currently in this store
Returns

Set/Boolean
:

A set of ids to apply changes to, or false to skip sync
keepExpandedOnLoad : Booleanfalse
StoreTree

When set to true, restores the expanded states of tree nodes when reloading data.
autoTree : Booleantrue

NON-LAZY-LOAD
Store

Automatically detect from set data if used as tree store or flat store. If tree is explicitly set to false, then this value will be overruled and no tree detection performed.
fireRemoveEventForMoveAction : Booleanfalse
StoreTree

Set to true to fire a 'remove' event when moving a node (to mimic the behavior of versions < 6.0).

transformFlatData : Boolean

StoreTree

Set to true to on load transform a flat dataset with raw objects containing parentId into the format expected for tree data.

Example input format:

[
  { id : 1, name : 'Parent' },
  { id : 2, name : 'Child', parentId : 1 }
]

Will be transformed into:

[
  {
    id       : 1,
    name     : 'Parent',
    children : [
      { id : 2, name : 'Child', parentId : 1 }
    ]
  }
]

tree : Boolean
Store

true to act as a tree store.

Properties

Properties are getters/setters or publicly accessible variables on this class

StopBranch : Symbol

static

StoreTree

A special Symbol signalizing treeify method that the current record grouping should be stopped.

const newRoot = workerStore.treeify([
    // group workers by company
    worker => {
        // if the worker is unemployed we don't put it in a group
        // we just show such record on the root level
        if (!worker.company) {
            return Store.StopBranch
        }

        return worker.company;
    }
]);

isEvents : Booleantrue

READONLY

static

ADVANCED
Events

Identifies an object as an instance of Events class, or subclass thereof.
isStoreCRUD : Booleantrue

READONLY

static

ADVANCED
StoreCRUD

Identifies an object as an instance of StoreCRUD class, or subclass thereof.
isStoreChained : Booleantrue

READONLY

static

ADVANCED
StoreChained

Identifies an object as an instance of StoreChained class, or subclass thereof.
isStoreChanges : Booleantrue

READONLY

static

ADVANCED
StoreChanges

Identifies an object as an instance of StoreChanges class, or subclass thereof.
isStoreFilter : Booleantrue

READONLY

static

ADVANCED
StoreFilter

Identifies an object as an instance of StoreFilter class, or subclass thereof.
isStoreGroup : Booleantrue

READONLY

static

ADVANCED
StoreGroup

Identifies an object as an instance of StoreGroup class, or subclass thereof.
isStorePaging : Booleantrue

READONLY

static

ADVANCED
StorePaging

Identifies an object as an instance of StorePaging class, or subclass thereof.
isStoreRelation : Booleantrue

READONLY

static

ADVANCED
StoreRelation

Identifies an object as an instance of StoreRelation class, or subclass thereof.
isStoreSearch : Booleantrue

READONLY

static

ADVANCED
StoreSearch

Identifies an object as an instance of StoreSearch class, or subclass thereof.
isStoreSort : Booleantrue

READONLY

static

ADVANCED
StoreSort

Identifies an object as an instance of StoreSort class, or subclass thereof.
isStoreSparseIndex : Booleantrue

READONLY

static

ADVANCED
StoreSparseIndex

Identifies an object as an instance of StoreSparseIndex class, or subclass thereof.
isStoreState : Booleantrue

READONLY

static

ADVANCED
StoreState

Identifies an object as an instance of StoreState class, or subclass thereof.
isStoreStm : Booleantrue

READONLY

static

ADVANCED
StoreStm

Identifies an object as an instance of StoreStm class, or subclass thereof.
isStoreSum : Booleantrue

READONLY

static

ADVANCED
StoreSum

Identifies an object as an instance of StoreSum class, or subclass thereof.
isStoreSync : Booleantrue

READONLY

static

ADVANCED
StoreSync

Identifies an object as an instance of StoreSync class, or subclass thereof.
isStoreTree : Booleantrue

READONLY

static

ADVANCED
StoreTree

Identifies an object as an instance of StoreTree class, or subclass thereof.
isVersionStore : Booleantrue

READONLY

static

ADVANCED

Identifies an object as an instance of VersionStore class, or subclass thereof.
configurable : Object

internal

static
Store
A class property getter for the configuration properties of the class, which can be overridden by configurations passed at construction time.

Unlike a normal static property, this property is only ever used for the class that defines it (as in, hasOwnProperty). It is retrieved for all classes in a class hierarchy, to gather their configs individually and then combine them with those of derived classes.

For example, a Label might declare a text config like so:
```
 class Label extends Base {
     static configurable = {
         text : null
     };
 }
```
The text config is automatically inherited by classes derived from Label. By implementing get configurable(), derived classes can change the default value of inherited configs, or define new configs, or both.

When a config property is declared in this way, the class author can also implement either of two special methods that will be called when the config property is assigned a new value:
- changeText()
- updateText()
In the example above, the Label class could implement a changeText() method, an updateText() method, or both. The generated property setter ensures these methods will be called when the text property is assigned.

The generated setter (for text in this example) performs the following steps:
- If the class defines a changeText() method, call it passing the new value and the current value: changeText(newText, oldText).
  Then:
  - If changeText() exits without returning a value (i.e., undefined), exit and do nothing further. The assumption is that the changer method has done all that is required.
  - Otherwise, the return value of changeText() replaces the incoming value passed to the setter.
- If the new value (or the value returned by changeText()) is !== to the current value:
  - Update the stored config value in this._text.
  - If the class defines an updateText() method, call it passing the new value and the previous value. updateText(newText, oldText)
Resolving a value from an owner

By specifying a value starting with 'up.' for a config, the config system will resolve that value by examining the ownership hierarchy. It will walk up the hierarchy looking for a property matching the name (or dot separated path) after 'up.'. If one is found, the value will be read and used as the initial value.
```
class Parent extends Base {
    static get configurable() {
        return [
          'importantValue'
        ]
    }
}

class Child extends Base {
    static get configurable() {
        return [
          'value'
        ]
    }
}

const parent = new Parent({
    importantValue : 123
});

const child = new Child({
    owner : parent,
    // Will be resolved from the owner
    value : 'up.importantValue'
});

console.log(child.value); // logs 123
```
Please note that this is for now a one way one time binding, the value will only be read initially and not kept up to date on later changes.

Value Merging

When a config property value is an object, the value declared by the base class is merged with values declared by derived classes and the value passed to the constructor.
```
 class Example extends Base {
     static configurable = {
         config : {
             foo : 1,
             bar : 2
         }
     };
 }

 class Example2 extends Example {
     static configurable = {
         config : {
             bar : 42,
             zip : 'abc'
         }
     };
 }

 let ex = new Example2({
     config : {
         zip : 'xyz'
     }
 });
```
The result of the merge would set config to:
```
 ex.foo = {
     foo : 1,    // from Example
     bar : 42,   // from Example2
     zip : 'xyz' // from constructor
 }
```
Config Options

Some config properties require additional options such as declarative information about the config that may be useful to automate some operation. Consider a Button. It could declare that its text config affects the rendered HTML by applying a render property to the config definition. Its base class could then examine the config definition to find this property.

To support this, config options ca be declared like so:
```
 class Button extends Widget {
     static configurable = {
         text : {
             value   : null,
             $config : {
                 render : true
             }
         }
     };
 }
```
The $config property can alternatively be just the names of the options that should be enabled (set to true).

For example, the following is equivalent to the above:
```
 class Button extends Widget {
     static configurable = {
         text : {
             value   : null,
             $config : 'render'
         }
     };
```
Default Value

It is common to set a config to a null value to take advantage of internal optimizations for null values. In most cases the fact that this produces undefined as the actual initial value of the config is acceptable. When this is not acceptable, a config can be declared like so:
```
 class Widget {
     static configurable = {
         disabled : {
             $config : null,
             value   : null,
             default : false
         }
     };
```
The default property above determines the value of the config while still gaining the benefits of minimal processing due to the null value of the value property.
declarable : String[]

internal

static
Store
A class property getter to add additional, special class properties.

For example, a class adds a declarable class property like so:
```
 class Something extends Base {
     static get declarable() {
         return ['extra'];
     }

     static setupExtra(cls, meta) {
         // use cls.extra
     }
 }
```
A derived class can then specify this property like so:
```
 class Derived extends Something {
     static get extra() {
         // return extra information
     }
 }
```
When the Derived class is initialized, the setupExtra() method is called and Derived is passed as the argument. It is also the this pointer, but the parameter is minifiable. The second argument passed is the $meta object for the class.

Classes are initialized at the first occurrence of the following:
- An instance is created
- The class $meta property is accessed
defaultConfig : Object

internal

static
Store
A legacy class property getter for the default configuration of the class, which can be overridden by configurations passed at construction time. We recommend using configurable instead.

Unlike a normal static property, this property is only ever used for the class that defines it (as in, hasOwnProperty). It is retrieved for all classes in a class hierarchy, to gather their configs individually and then combine them with those of derived classes.

For example, a Store might declare its url config like so:
```
 class Store extends Base {
     static get defaultConfig() {
         return {
             url : null
         };
     }
 }
```
The url config is automatically inherited by classes derived from Store. By implementing get defaultConfig(), derived classes can change the default value of inherited configs, or define new configs, or both. When defining new configs, however, configurable is preferred.

Config properties introduced to a class by this declaration do not participate in value merging and do not get a generated setter. Config properties introduced by a base class using configurable can be set to a different value using defaultConfig and in doing so, the values will be merged as appropriate for configurable.
properties : Object

internal

static
Store

A class property getter for the default values of internal properties for this class.
$meta : Object

internal

READONLY

static
Store
An object owned by this class that does not share properties with its super class. This object may contain other properties which are added as needed and are not documented here.
- class : Function
  
  The class constructor that owns the meta object
- super : Object
  
  The $meta object for the super class. This is null for Base
- config : Object
  
  The object holding the default configuration values for this class
- configs : Object
  
  An object keyed by config name that holds the defined configs for the class The value of each property is a Config instance
- forkConfigs : Boolean
  
  This will be true if the default configuration values for this class (in the config property of the meta object) must be forked to avoid object sharing, or if the object can be passed to Object.create() for efficiency
- hierarchy : Function[]
  
  The array of classes in the ancestry of this class. This will start with Base at index 0 and ends with this class
- properties : Function[]
  
  The array of classes that define a "static get properties()" getter
stores : Store[]

READONLY

static
Store

Get all registered stores

id : String/Number

READONLY
Store

Store's unique identifier.

Has a corresponding id config.
applyChangesetFilterSortTarget : 'changes'/'none'changes
StoreChanges
Specifies target to filter and sort after applying changeset:
- 'changes' - apply sort and filter to changeset only (see more below)
- 'none' - do not apply sort and filter
changes behavior

If the store has filters in effect when the changeset is applied, the following rules will determine how the filtered values are affected:
- Among added records, only those that match the filter will be included in the filtered set
- Among updated records, those that did not previously match the filter but now do will be added to the filtered set, and those that did match but no longer do will also remain in the filtered set. This means that new records may appear in the filtered set as a result of applyChanges, but records will not disappear until filters are re-applied.
Does not apply if the store is remotely filtered.

Has a corresponding applyChangesetFilterSortTarget config.
baseStore : Store

READONLY
StoreChained

Returns the root store in the chain — the store that is not itself chained. For a store chained off another chained store, this walks up the full chain. Returns this if the store is not chained.
ignoreRemoteChangesInSTM : Booleanfalse
StoreStm

Set to false to not record transaction during applyChangeset call

Has a corresponding ignoreRemoteChangesInSTM config.
isChained : Boolean

READONLY

NON-LAZY-LOAD
StoreChained

Is this a chained store?
isRemoteLoad : Boolean

READONLY
Store

Returns true if the data in this store depends on a remote data source. That is this Store is an AjaxStore, or uses requestData, or is chained off an AjaxStore.
emptyArray : Array

internal

READONLY
Store

An empty array that can be used as a default value.
emptyObject : Object

internal

READONLY
Store

An empty object that can be used as a default value.
isStore : Booleantrue

READONLY

ADVANCED
Store

Identifies an object as an instance of Store class, or subclass thereof.
isVersionStore : Booleantrue

READONLY

ADVANCED

Identifies an object as an instance of VersionStore class, or subclass thereof.
catchEventHandlerExceptions : Booleanfalse

ADVANCED
Events

By default, if an event handler throws an exception, the error propagates up the stack and the application state is undefined. Code which follows the event handler will not be executed.

Set this to true to catch exceptions thrown by this object's event handlers and continue processing the event. The exception will be rethrown on a zero millisecond timeout, so it will not destroy the stack.

Has a corresponding catchEventHandlerExceptions config.
reapplySortersOnUpdate : Boolean/Object
StoreSort
Specify true to reapply sorting when a record is updated in the store. You can also provide an array of field names, to only trigger sort when certain data fields are updated.

If the app processes many records or many record fields in a loop or similar, be sure to temporarily disable this setting. Otherwise, each change will trigger a sort, which will make the processing slow
- fields : String[]
  
  Fields that reapply sorting when updated
Has a corresponding reapplySortersOnUpdate config.
config : Object

READONLY

ADVANCED
Store

Returns a copy of the full configuration which was used to configure this object.
isConstructing : Boolean

READONLY

ADVANCED
Store

This property is set to true before the constructor returns.
isDestroyed : Boolean

READONLY
Store

This property is set to true by destroy after destruction.

It is also one of the few properties that remains on the object after returning from destroy(). This property is often checked in code paths that may encounter a destroyed object (like some event handlers) or in the destruction path during cleanup.
isDestroying : Boolean

READONLY

ADVANCED
Store

This property is set to true on entry to the destroy method. It remains on the objects after returning from destroy(). If isDestroyed is true, this property will also be true, so there is no need to test for both (for example, comp.isDestroying || comp.isDestroyed).
callOnFunctions : Booleanfalse
Events
Set to true to call onXXX method names (e.g. onShow, onClick), as an easy way to listen for events.
```
const container = new Container({
    callOnFunctions : true

    onHide() {
         // Do something when the 'hide' event is fired
    }
});
```
Has a corresponding callOnFunctions config.
isPaged : Boolean

READONLY

NON-LAZY-LOAD
StorePaging

Yields true if this Store is loaded page by page. See the remotePaging config.
lastPage : Number

READONLY

NON-LAZY-LOAD
StorePaging

If the store is paged, yields the highest page number in the dataset as calculated from the 'total' returned in the last page data block loaded.
pageSize : Number50

NON-LAZY-LOAD
StorePaging

When the Store is paged by configuring remotePaging, this value will be included in the load requests.

Note: Setting pageSize at runtime will automatically reload the page.

Has a corresponding pageSize config.
allRecords : Model[]

READONLY
Store

Returns all locally available records from the store, ignoring any filters and including grouping headers / footers.
autoCommit : Boolean
StoreCRUD

Setting autoCommit to true automatically commits changes to records.

Has a corresponding autoCommit config.
changes : Object

READONLY
StoreCRUD
Get uncommitted changes as an object of added/modified/removed arrays of records.
```
// Format:
{
     added: [], // array of Core.data.Model
     modified: [], // array of Core.data.Model
     removed: [] // array of Core.data.Model
}
```
- added : Model[]
  
  Records that have been added
- modified : Model[]
  
  Records that have changes to persistable fields
- removed : Model[]
  
  Records that have been removed

count : Number

READONLY

Store

Record count, including records added for group headers etc., excluding collapsed or filtered away records. That is, count is the "visible record count", if the store is used in a Grid or other component that visualize the records.

Consider the following dataset loaded into a Store:

[
  { id : 1, name : 'Linda', city : 'NY' },
  { id : 2, name : 'Olivia', city : 'NY' },
  { id : 3, name : 'John', city : 'Stockholm' }
]

// count === 3

Grouping by city yields the following records in the Store (pseudocode):

store.group('city');

[
  { name : 'Group NY', groupHeader : true, expanded : true },
  { id : 1, name : 'Linda', city : 'NY' },
  { id : 2, name : 'Olivia', city : 'NY' },
  { name : 'Group Stockholm', groupHeader : true },
  { id : 3, name : 'John', city : 'Stockholm', expanded : true }
]

// count === 5

Collapsing the Stockholm group yields the following records in the Store (pseudocode):

store.collapse(store.getAt(3));

[
  { name : 'Group NY', groupHeader : true, expanded : true },
  { id : 1, name : 'Linda', city : 'NY' },
  { id : 2, name : 'Olivia', city : 'NY' },
  { name : 'Group Stockholm', groupHeader : true, expanded : false }
]

// count === 4

Applying a filter further affects the count (pseudocode):

store.filter('name', 'Linda');

[
  { name : 'Group NY', groupHeader : true, expanded : true },
  { id : 1, name : 'Linda', city : 'NY' }
]

// count === 2

If you need a different value for count in your app, for example ignoring filters, or including collapsed away records, please use the more flexible getCount function instead.

If the store is configured with lazyLoad, this number is based on the total amount of records specified in the response given to the requestData function.

data : Object[]

NON-LAZY-LOAD
Store
Sets data in the store.

Expects an array of JavaScript objects, with properties matching store's fields (defined on its model or in the fields config).

Called on initialization if data is in the config, otherwise call it yourself after for example using fetch to get remote data:
```
store.data = [
    { id : 1, name : 'Linda', city : 'NY' },
    { id : 2, name : 'Olivia', city : 'Paris' },
    ...
];
```
Can also be used to get an array of the current raw data objects from all records in the store (ignoring filtering and grouping):
```
console.log(store.data);
// [
//     { id : 1, name : 'Linda', city : 'NY' },
//     { id : 2, name : 'Olivia', city : 'Paris' },
//     ...
// ]
```
You should not modify the objects in the array, neither the store nor the record will be aware of the changes.

Has a corresponding data config.
first : Model

READONLY
Store

Get the first record locally available in the store.
hasChanges : Boolean

READONLY
StoreCRUD

Boolean flag, indicating whether the store has any data changes (its changes accessor returns a non-empty object). Cheaper than changes accessor itself, because it does not clone some internal data structures.
last : Model

READONLY
Store

Get the last record locally available in the store.
modelClass : Model
Store

Class used to represent records. Defaults to class Model.

Has a corresponding modelClass config.
records : Model[]

READONLY

IMMUTABLE
Store

Returns all locally available "visible" records. Note: The returned value may not be mutated!
totalCount : Number
Store

Yields the complete dataset size, ignoring filtering and grouping. If the store is paged, it returns the total value provided in the page load request response, or manually set.
filters : Collection

READONLY
StoreFilter

Currently applied filters. A collection of CollectionFilter instances.

Has a corresponding filters config.
groupers : Grouper[]
StoreGroup

Currently used groupers. To set groupers when remote sorting is enabled by sortParamName you should use setGroupers instead to be able to wait for the operation to finish.

Has a corresponding groupers config.
isFiltered : Boolean

READONLY
StoreFilter

Check if store is filtered
isGrouped : Boolean

READONLY
StoreGroup

Is store currently grouped?
isSorted : Boolean

READONLY
StoreSort

Is store sorted?
sorters : Sorter[]

READONLY
StoreSort

Currently applied sorters

Has a corresponding sorters config.
formattedJSON : String

READONLY
Store

Pretty printed version of json

json : String

NON-LAZY-LOAD

Store

Retrieve or set the data of all records as a JSON string

const store = new Store({
    data : [
        { id : 1, name : 'Superman' },
        { id : 2, name : 'Batman' }
    ]
});

const jsonString = store.json;

//jsonString:
'[{"id":1,"name":"Superman"},{"id":2,"name":"Batman"}]

verifyNoGeneratedIds : Booleantrue
Store

Verify that loaded data does not contain any generated ids. If it does, a warning is logged on console.

Set this to false to disable the check and give a very minor performance boost.

Has a corresponding verifyNoGeneratedIds config.
groupHeaderRecords : Model[]

READONLY

NON-LAZY-LOAD
StoreGroup

Returns all the group header records
currentPage : Number

READONLY
StorePaging

If the store is paged, yields the current page number.
sorterFn : Function

internal

READONLY
StoreSort

The sorter function for sorting records in the store.
isTree : Boolean

READONLY
StoreTree

true if this Store is configured to handle tree data (with tree : true) or if this is a chained store and the master store is a tree store.
leaves : Model[]

READONLY
StoreTree

Returns all leaf records in a tree store
rootNode : Model

READONLY
Store

The invisible root node of this tree.

Functions

Functions are methods available for calling on the class

hasConfigPath( object, path )
: Boolean

internal

static
Store

Determines if the specified config property exists in an instance of Base
mergeConfigs( baseConfig, ...configs )
: Object

internal

static
Store

Returns the merge of the baseConfig and config config objects based on the configs defined by this class.
new( ...configs )
: Base

private

static
Store

Factory version of the Base constructor. Merges all arguments to create a config object that is passed along to the constructor.
onClassMixedIn( )

internal

static
Store

This optional class method is called when a class is mixed in using the mixin() method.
applyDefaults( defaultsObj )

static

ADVANCED
Store
Merges the provided default configuration values with the existing defaults for this class (and its subclasses).

This method allows you to define additional or override existing default property values that apply to all instances of the class.
```
// All my input fields should be clearable
 Field.applyDefaults({
     clearable : true
});
```
getDefaultConfiguration( )
: Object

internal

static
Store

Gets the full defaultConfig block for this object's entire inheritance chain all the way up to but not including Base
setupConfigs( meta, configs, simple )

private

static
Store

This method is called as part of setupClass(). It will process the configurable() return object and the defaultConfig return object.
destroy( ...args )

static

ADVANCED
Store
Destroys the provided objects by calling their destroy method. Skips empty values or objects that are already destroyed.
```
Base.destroy(myButton, toolbar1, helloWorldMessageBox);
```
initClass( )

static

ADVANCED
Store

Registers this class type with its Factory
isOfTypeName( type )
: Boolean

static

ADVANCED
Store

Checks if an obj is of type using object's $name property and doing string comparison of the property with the type parameter.
mixin( ...mixins )
: Function

static

ADVANCED
Store
Applies one or more mixins to this class and returns the produced class constructor.

For example, instead of writing this:
```
 class A extends Delayable(Events(Localizable(Base))) {
     // ...
 }
```
Using this method, one would write this:
```
 class A extends Base.mixin(Localizable, Events, Delayable) {
     // ...
 }
```
If one of the mixins specified has already been mixed into the class, it will be ignored and not mixed in a second time.
setupClass( meta )

internal

static
Store

This method is called only once for any class. This can occur when the first instance is created or when the $meta object is first requested.

from( config, defaults, converterFn )

private

static

Store

Retrieves/creates a store based on the passed config.

Type	Result
Core.data.Store	Returns supplied store as is
String	Retrieves an existing store by id
Object	Creates a new store using supplied config object
Object[]	Creates a new store, populated with records created from supplied data
Core.data.Model[]	Creates a new store, populated with supplied records

getStore( id, storeClass )
: Store

static
Store
Creates a new Store instance, or retrieves an existing one.

A Store config object may contain a type property to identify a specific Store subclass to create. If type is not specified, a base Store instance will be created.

Get a store by passing in the id of an existing store:
```
// Get a store by id
const store = Store.getStore('myStoreId');
```
Create a store from an array of data objects:
```
const store = Store.getStore([
    { id : 1, name : 'Linda', city : 'NY' },
    { id : 2, name : 'Olivia', city : 'Paris' },
    ...
]);
```
Create a store from a config object using a type property to identify a specific Store subclass to create:
```
const store = Store.getStore({
    type       : 'tree',
    modelClass : MyModel,
    data       : [
        { id : 1, name : 'Linda', city : 'NY' },
        { id : 2, name : 'Olivia', city : 'Paris' },
        ...
    ]
});
```

constructor( ...args )

ADVANCED
Store

Base constructor, passes arguments to construct.
_thisIsAUsedExpression( expression )

internal
Store

This method is required to help unused getters to survive production build process. Some tools, like angular, will remove unused code in production build, making our side-effected getters behind, breaking code heavily.
bindConfigs( target, mapping, options )
: Function

internal
Store

Creates a binding between the specified config properties of this object and the specified target object. Changes to these config properties of this object will be reflected to the target object as they occur, and (optionally), vise-versa.

Returns a function to call to remove the binding.
delay( fn, delay, name )
: Number

private
Store

Delays the execution of the passed function by the passed time quantum, or if the time is omitted or not a number, delays until the next animation frame. Note that this will use setTimeout || requestAnimationFrame if this class mixes in Delayable, otherwise it uses the global methods. The function will be called using this object as its execution scope.
hasConfig( name )
: Boolean

internal
Store

Returns true if this instance has a non-null value for the specified config. This will not activate a lazy config.
peekConfig( name )
: *

internal
Store

Returns the value of an uningested config without ingesting the config or transforming it from its raw value using its changeXxxxx method.
trackDetacher( name, detacher )

private
Store

Tracks a detacher function for the specified listener name.
triggerConfig( name )
: Boolean

internal
Store

Ensures that the specified config is initialized if it is needed. If there is a config value specified, and it was initialized by this call, this method returns true. If there was a config value specified, and it was already initialized, this method returns false. If there was no value specified for the given config, this method returns null.

This is not the same as just reading the property, because some property getters exist that do not actually just read the config value back, but instead produce some result. Reading such properties to incidentally trigger a possible config initializer can lead to incorrect results. For example, the Combo items config.
triggerConfigs( group )
: String[]

internal
Store

This call will activate any pending lazy configs that were assigned a string value equal to the group parameter.
untrackDetachers( eventer )

private
Store

Removes all detacher functions for the specified Events object. This is called by the removeAllListeners method on that object which is typically called by its destroy invocation.
updateConfiguration( props )

internal
Store

This is intended to set a block of configs during configuration. It is not intended to be used outside of the configuration phase.

If any of the properties are not yet ingested from the configuration object, they will be set and ingested in the normal order.

Properties which are already ingested are set immediately.
applyChangesFromStore( otherStore )
StoreChanges

Applies changes from another store to this store. Useful if cloning records in one store to display in a grid in a popup etc. to reflect back changes.
applyChangeset( changes, transformFn, phantomIdField$PhantomId, clearChangestrue )
StoreChanges
Applies a set of changes (presumable from a backend) expressed as an object matching the format outputted by the changes property: { added : [], modified/updated : [], removed : [] }

added is expected to be an array of raw data objects consumable by the stores model class for records to add to the store (see example snippet below).

modified (or updated for compatibility with Schedulers CrudManager) is expected to have the same format as added, but should always include the id of the record to update.

Records that have been created locally and gets assigned a proper id by the backend are expected to also pass a phantomId field (name of the field is configurable using the phantomIdField arg, more info on phantom ids below), to match it with the current id of a local record (id will contain the new id).

Note that it is also possible to pass this phantomId -> id mapping in the added array. When encountering a record in that array that already exists in the local store, it will be treated the same way as a record in the modified array.

removed is expected to be an array of objects with the { id : xx } shape. Any matches on an id in the store will be removed, those and any non-matches will also be cleared from the change tracking of the store.

If the store has filters in effect when the changeset is applied, the following rules will determine how the filtered values are affected:
- Among added records, only those that match the filter will be included in the filtered set
- Among updated records, those that did not previously match the filter but now do will be added to the filtered set, and those that did match but no longer do will also remain in the filtered set. This means that new records may appear in the filtered set as a result of applyChanges, but records will not disappear until filters are re-applied.
As an example, consider a store with the following initial state and some operations performed on it:
```
// Load some data
store.data = [
    { id : 1, name : 'Minerva' },
    { id : 2, name : 'Mars' },
    { id : 3, name : 'Jupiter' }
];
// Add a new record. It gets assigned a generated id,
// for example, 'generated56'
store.add({ name : 'Artemis' });
// Remove Jupiter
store.remove(3);
```
After syncing those operations to a custom backend (however, you chose to solve it in your application), we might get the following response (see "Transforming a response to the correct format" below if your backend responds in another format):
```
const serverResponse = {
    added : [
        // Added by the backend, will be added locally
        { id : 5, name : 'Demeter' }
    ],

    updated : [
        // Will change the name of Minerva -> Athena
        { id : 1, name : 'Athena' },
        // Will set proper id 4 for Artemis
        { $PhantomId : 'generated56', id : 4 }
    ],

    removed : [
        // Confirmed remove of Jupiter
        { id : 3 },
        // Removed by the backend, Mars will be removed locally
        { id : 2 }
    ]
};
```
If that response is then passed to this function:
```
store.applyChangeset(serverResponse);
```
The result will be the following data in the store:
```
[
    { id : 1, name : 'Athena' }, // Changed name
    { id : 4, name : 'Artemis' }, // Got a proper id
    { id : 5, name : 'Demeter' } // Added by the backend
]
```
Phantom ids

When a record is created locally, it is always assigned a generated id. That id is called a phantom id (note that it is assigned to the normal id field). When passing the new record to the backend, the id is sent with it. When the backend inserts the record into the database, it (normally) gets a proper id assigned. That id then needs to be passed back in the response, to update the local record with the correct id. Making sure that future updates match the correct row in the database.

For example, a newly created record should be passed similar to this to the backend (pseudo format, up to the application/backend to decide):
```
{
    "added" : {
        "id" : "generated79",
        "name" : "Hercules",
        ...
    }
}
```
For the backend response to be applicable for this function, it should then respond with:
```
{
    "updated" : {
        {
            "$PhantomId" : "generated79",
            "id" : 465
        }
    }
}
```
(Or, as stated above, it can also be passed in the "added" array. Whichever suits your backend best).

This function will then change the id of the local record using the phantom id generated79 to 465.

Transforming a response to the correct format

This function optionally accepts a transformFn, a function that will be called with the changes. It is expected to return a changeset in the format described above ({ added : [], updated : [], removed : [] }), which then will be used to apply the changes.

Consider the following "non-standard" (made-up) changeset:
```
const changes = {
    // Database ids for records previously added locally
    assignedIds : {
        'phantom1' : 10,
        'phantom2' : 15
    },
    // Ids records removed by the backend
    removed : [11, 27],
    // Modified records, keyed by id
    altered : {
        12 : { name : 'Changed' }
    },
    // New records, keyed by id
    inserted : {
        20  : { name : 'New' }
    }
}
```
Since it does not match the expected format, it has to be transformed:
```
store.applyChangeset(changes, ({ assignedIds, inserted, altered, removed }) => ({
   // Convert inserted to [{ id : 20, name : 'New' }]
   added : Object.entries(inserted).map(([id, data] => ({ id, ...data }),
   updated : [
       // Convert assignedIds to [{ $PhantomId : 'phantom1', id : 10 }, ...]
      ...Object.entries(assignedIds).map(([phantomId, id])) => ({ $PhantomId : phantomId, id }),
      // Convert altered to [{ id : 12, name : 'Changed' }]
      ...Object.entries(modified).map(([id, data] => ({ id, ...data })
   ],
   // Convert removed to [{ id : 11 }, ...]
   removed : removed.map(id => ({ id }))
}));
```
The transform function above would output:
```
{
    added : [
        {  id : 20, name : 'New' }
    ],
    updated : [
        { $PhantomId : 'phantom1', id : 10 },
        { $PhantomId : 'phantom2', id : 15 },
        {  id : 12, name : 'Changed' }
    ],
    removed : [
       { id : 11 },
       { id : 12 }
    ]
}
```
And that format can then be applied.

Preventing automatic commit of applied changes

By default, the clearChanges parameter is set to true, which automatically commits applied changes to the store. Setting this parameter to false prevents the automatic commit, keeping the store in a dirty state.

For example, the following will apply changes without committing them:
```
const changes = {
    added : [
        {  id : 20, name : 'New' }
    ],
    updated : [
        { id : 10, name : 'Fiona' },
    ],
    removed : [
       { id : 11 }
    ]
};

// Apply these changes using the applyChangeset method
store.applyChangeset(changes, null, '$PhantomId', false);
```
clear( )

private
StoreCRUD

Clears store data. Used by removeAll, separate function for using with chained stores.
commit( silentfalse )
: Object

StoreCRUD

Commits changes, per default only returns changes and resets tracking.

Triggers: beforeCommit, commit
loadPage( page, params )
: Promise

ASYNC

NON-LAZY-LOAD
StorePaging

Loads a page of data from the implemented requestData function.
nextPage( )
: Promise

ASYNC

NON-LAZY-LOAD
StorePaging

If this store is paged, and is not already at the lastPage then this will load the next page of data.
previousPage( )
: Promise

ASYNC

NON-LAZY-LOAD
StorePaging

If this store is paged, and is not already at the first page then this will load the previous page of data.
removeAll( silentfalse )
: Boolean

NON-LAZY-LOAD
StoreCRUD

Removes all records from the store.

If called on a lazy-loaded store, it removes all the loaded records. And if a backend is configured, then those deletions will also be synced with the backend.

Triggers: beforeRemove, removeAll, change
revertChanges( )
StoreCRUD

Reverts all changes in the store (adds removed records back, and removes newly added records).

Triggers: change, refresh
chain( chainedFilterFn, chainedFields, config )
: Store

NON-LAZY-LOAD
StoreChained
Creates a chained store, a new Store instance that contains a subset of the records from current store. Which records is determined by a filtering function, which is reapplied when data in the base store changes.
```
// Chain all records
const all = store.chain();

// Or a subset using a filter function
const oldies = store.chain(record => record.age > 50);
```
If you want to chain a tree store, consider using chainTree instead. It will create a new tree store with links to the records in this store. This will let you expand/collapse and filter nodes in the chained store without affecting the original store.

If this store is a tree store, then the resulting chained store will be a tree store sharing the same root node, but only child nodes which pass the chainedFilterFn will be considered when iterating the tree through the methods such as traverse or forEach.
chainTree( chainedFilterFn, chainedFields, config )
: Store

NON-LAZY-LOAD
StoreChained
Creates a chained tree store, a new Store instance that contains a subset of the records from current store. Which records is determined by a filtering function, which is reapplied when data in the base store changes.
```
// Chain all nodes
const fullTree = store.chainTree();
// Or a subset
const oldies = store.chainTree(record => record.age > 50);
```
The resulting chained store will be a tree store with its own root node, under which all children are links to the nodes in this store. This allows for expanding/collapsing and filtering nodes in the chained store without affecting the original store.
fillFromMaster( )

NON-LAZY-LOAD
StoreChained

Updates records available in a chained store by filtering the master store records using chainedFilterFn
classHierarchy( topClass )
: Function[]

private
Store

Used by the Widget and GridFeatureManager class internally. Returns the class hierarchy of this object starting from the topClass class (which defaults to Base).

For example classHierarchy(Widget) on a Combo would yield [Widget, Field, TextField, PickerField, Combo]
getConfig( name, ...names )
: *

internal
Store
Returns the value of the specified config property. This is a method to allow property getters to be explicitly called in a way that does not get optimized out.

The following triggers the getter call, but optimizers will remove it:
```
 inst.foo;   // also raises "expression has no side-effects" warning
```
Instead, do the following to trigger a getter:
```
 inst.getConfig('foo');
```
getProperties( )
: Object

private
Store

Gets the full properties block for this class's entire inheritance chain all the way up to but not including Base
onConfigChange( info )

internal
Store

This method is called when any config changes.
addListener( config, thisObj, oldThisObj )
: Function

Events
Adds an event listener. This method accepts parameters in the following format:
```
 myObject.addListener({
     thisObj    : this,          // The this reference for the handlers
     eventname2 : 'functionName' // Resolved at invocation time using the thisObj,
     otherevent : {
         fn      : 'handlerFnName',
         once    : true          // Just this handler is auto-removed on fire
     },
     yetanother  : {
         fn      : 'yetAnotherHandler',
         args    : [ currentState1, currentState2 ] // Capture info to be passed to handler
     },
     prio        : 100           // Higher prio listeners are called before lower
 });
```
When listeners have a thisObj option, they are linked to the lifecycle of that object. When it is destroyed, those listeners are removed.

The config parameter allows supplying options for the listener(s), for available options see BryntumListenerConfig.

A simpler signature may be used when only adding a listener for one event and no extra options (such as once or delay) are required:
```
myObject.addListener('click', myController.handleClicks, myController);
```
The args in this simple case are eventName, handler and thisObj

By default, if an event handler throws an exception, the error propagates up the stack and the application state is undefined. Code which follows the event handler will not be executed. Set the catchEventHandlerExceptions config to true to catch exceptions thrown by this object's event handlers and allow the event to continue processing. The exception will be rethrown on a zero millisecond timeout,
attachAutoDetacher( )

private
Events

Internal function used to hook destroy() calls when using thisObj
await( eventName, options )
: Promise

private

ASYNC
Events
detachAutoDetacher( )

private
Events

Internal function used restore hooked destroy() calls when using thisObj
detachListeners( name )

ADVANCED
Store

Removes all event listeners that were registered with the passed names.
doDestroy( )

internal
Events

Auto detaches listeners registered from start, if set as detachable
findListener( eventName, listenerToFind, defaultThisObj )

internal
Events

Finds the index of a particular listener to the named event. Returns -1 if the passed function/thisObj listener is not present.
hasListener( eventName )
: Boolean

ADVANCED
Events

Returns true if any listener is registered for the specified eventName, or if null, for any event.
ion( )

internal
Events

Internal convenience method for adding an internal listener, that cannot be removed by the user.

Alias for on({ $internal : true, ... }). Only supports single argument form.
numListeners( eventName )
: Number

internal
Events

Returns the number of attached listener for the specified eventName, or if null, for any event.

on( config, thisObj, oldThisObj )

: Function

Events

Alias for addListener. Adds an event listener. This method accepts parameters in the following format:

 myObject.on({
     thisObj    : this,          // The this reference for the handlers
     eventname2 : 'functionName' // Resolved at invocation time using the thisObj,
     otherevent : {
         fn      : 'handlerFnName',
         once    : true          // Just this handler is auto-removed on fire
     },
     yetanother  : {
         fn      : 'yetAnotherHandler',
         args    : [ currentState1, currentState2 ] // Capture info to be passed to handler
     },
     prio        : 100           // Higher prio listeners are called before lower
 });

When listeners have a thisObj option, they are linked to the lifecycle of that object. When it is destroyed, those listeners are removed.

The config parameter allows supplying options for the listener(s), for available options see BryntumListenerConfig.

A simpler signature may be used when only adding a listener for one event and no extra options (such as once or delay) are required:

myObject.on('click', myController.handleClicks, myController);

The args in this simple case are eventName, handler and thisObj

onListen( eventName )

internal
Events

This method is called when the first listener for an event is added.
onUnlisten( eventName )

internal
Events

This method is called when the last listener for an event is removed.
once( )

private
Events

Internal function used to run a callback function after an event is triggered

relayAll( through, prefix, transformCasetrue )

ADVANCED

Events

Relays all events through another object that also implements Events mixin. Adds a prefix to the event name before relaying, for example add -> storeAdd

// Relay all events from store through grid, will make it possible to listen for store events prefixed on grid:
'storeLoad', 'storeChange', 'storeRemoveAll' etc.
store.relayAll(grid, 'store');

grid.on('storeLoad', () => console.log('Store loaded');

removeAllListeners( )
Events

Removes all listeners registered to this object by the application.
removeListener( config, thisObj, oldThisObj )
: Boolean

Events

Removes an event listener. Same API signature as addListener
resumeEvents( )
: Boolean

ADVANCED
Events

Resume event triggering after a call to suspendEvents(). If any triggered events were queued they will be triggered.
suspendEvents( queuefalse )

ADVANCED
Events

Prevents events from being triggered until resumeEvents() is called. Optionally queues events that are triggered while suspended. Multiple calls stack to require matching calls to resumeEvents() before actually resuming.
trigger( eventName, param )
: Boolean/Promise

ASYNC

ADVANCED
Events

Triggers an event, calling all registered listeners with the supplied arguments. Returning false from any listener makes function return false.

By default, if an event handler throws an exception, the error propagates up the stack and the application state is undefined. Code which follows the event handler will not be executed. Set the catchEventHandlerExceptions config to true to catch exceptions thrown by this object's event handlers and allow the event to continue processing. The exception will be rethrown on a zero millisecond timeout,
un( config, thisObj, oldThisObj )
: Boolean

Events

Shorthand for removeListener
excludeGroupRecords( groupRecord )

private
StoreGroup

Removes records in a group from storage. Used when collapsing a group.
includeGroupRecords( groupRecord )

private
StoreGroup

Adds records in a group to storage. Used when expanding a group.
internalIncludeExcludeGroupRecords( groupRecord, include )

private
StoreGroup

Adds or removes records in a group from storage. Used when expanding/collapsing groups.
every( fn, thisObj, ignoreFilters )
: Array

Store

Equivalent to Array.every(). Returns true if every call of the provided function on each record yields a truthy value.
flatMap( fn, thisObj )
: Array

Store

Equivalent to Array.flatMap(). Creates a new array by spreading the results of calling a provided function on every record
forEach( fn, thisObj, options )
Store

Iterates over all available records in store. Omits group header and footer records if this store is grouped. Does not request new records when store is configured with lazyLoad.
map( fn, thisObj )
: Array

Store

Equivalent to Array.map(). Creates a new array with the results of calling a provided function on every record
reduce( fn, initialValue, thisObj )
: *

Store

Equivalent to Array.reduce(). Applies a function against an accumulator and each record (from left to right) to reduce it to a single value.
afterConfigure( )

internal
Store

Base implementation so that all subclasses and mixins may safely call super.afterConfigure. This is called by the Base class after the configure method has been called. At this point, all configs have been applied.

This method allows all classes in the hierarchy to inject functionality either before or after the super.afterConstruct();
afterConstruct( )

internal
Store

Base implementation so that all subclasses and mixins may safely call super.afterConstruct.

This is called by the Base class after the construct method has been called.

At this point, all configs have been applied.

This method allows all classes in the hierarchy to inject functionality either before or after the super.afterConstruct();
configure( config )

internal
Store

Called by the Base constructor to apply configs to this instance. This must not be called.
construct( ...args )

ADVANCED
Store

Base implementation applies configuration.

Subclasses need only implement this if they have to initialize instance specific properties required by the class. Often a construct method is unnecessary. All initialization of incoming configuration properties can be done in a set propName implementation.
destroyProperties( ...properties )

internal
Store
Destroys the named properties if they have been initialized, and if they have a destroy method. Deletes the property from this object. For example:
```
 this.destroyProperties('store', 'resourceStore', 'eventStore', 'dependencyStore', 'assignmentStore');
```
finishConfigure( )

internal
Store

Base implementation so that all subclasses and mixins may safely call super.finishConfigure.

This is called by the Base class before exiting the configure method.

At this point, all configs have been applied, but the isConfiguring property is still set.

This method allows all classes in the hierarchy to inject functionality into the config phase.
setConfig( config )

ADVANCED
Store

Sets configuration options this object with all the properties passed in the parameter object. Timing is taken care of. If the setter of one config is called first, and references the value of another config which has not yet been set, that config will be set just in time, and the new value will be used.
startConfigure( )

internal
Store

Base implementation so that all subclasses and mixins may safely call super.startConfigure.

This is called by the Base class before setting configuration properties, but after the active initial getters have been set, so all configurations are available.

This method allows all classes in the hierarchy to force some configs to be evaluated before others.
animateProperty( propertyName, newValue, duration1000, easing'linear' )
Store

Changes the value of a numeric property of this object smoothly over the specified duration.
callback( fn, thisObject, args )

ADVANCED
Store

Provides a way of calling callbacks which may have been specified as the name of a function and optionally adds scope resolution.

For example, if the callback is specified as a string, then if it is prefixed with 'this.' then the function is resolved in this object. This is useful when configuring listeners at the class level.

If the callback name is prefixed with 'up.' then the ownership hierarchy is queried using the owner property until an object with the named function is present, then the named function is called upon that object.

If a named function is not found, an error is thrown. If the function should be only called when present, and may not be present, add a ? as a suffix.
downloadTestCase( )
Store

Experimental helper function, extracts the currently used configs and wraps them as an app, downloading the resulting JS file.

This function is intended to simplify creating test cases for issue reporting on Bryntum's support forum.
resolveCallback( handler, thisObj, enforceCallabilitytrue )
: Object

ADVANCED
Store

Provides a way of locating callbacks which may have been specified as the name of a function and optionally adds scope resolution.

For example, if the callback is specified as a string, then if it is prefixed with 'this.' then the function is resolved in this object. This is useful when configuring listeners at the class level.

If the callback name is prefixed with 'up.' then the ownership hierarchy is queried using the owner property until an object with the named function is present, then the named function is called upon that object.
createRecord( data, skipExposefalse )
: Model

Store

Creates a model instance, used internally when data is set/added. Override this in a subclass to do your own custom conversion from data to record.
getAt( index )
: Model

Store

Get the record at the specified index.
getById( id )
: Model

Store

Get a locally available record by id. Find the record even if filtered out, part of collapsed group or collapsed node
getByIds( recordsOrIds )
: Model[]

Store
Resolves an input of record(s) and/or id(s) into an array of records found in this store. Accepts a single record, a single id, or an array mixing both. Entries that don't resolve to a record in this store are silently skipped.
```
const records = store.getByIds([1, 5, someRecord, 'abc']);
```
getByInternalId( internalId )
: Model

Store

Get a record by internalId.

getCount( optionstrue )

: Number

Store

Counts the number of records in the store. Allows passing an options object to control which records are counted. For example:

store.getCount({ filteredOut : true });
store.getCount({ headersFooters : true, collapsed : true });

Consider the following dataset loaded into a Store:

[
  { id : 1, name : 'Linda', city : 'NY' },
  { id : 2, name : 'Olivia', city : 'NY' },
  { id : 3, name : 'John', city : 'Stockholm' }
]

No grouping or filtering is applied, thus all records are accessible ("visible"). Passing the different options below would yield the following results:

Option	Count	Description
`filteredOut`	0	No records are filtered out
`headersFooters`	0	No group headers have been generated
`collapsed`	0	No groups are collapsed
`visibleData`	3	All data records are "visible"
`all`	3	All options combined

Grouping by city yields the following records in the Store (pseudocode):

store.group('city');

[
  { name : 'Group NY', groupHeader : true, expanded : true },
  { id : 1, name : 'Linda', city : 'NY' },
  { id : 2, name : 'Olivia', city : 'NY' },
  { name : 'Group Stockholm', groupHeader : true },
  { id : 3, name : 'John', city : 'Stockholm', expanded : true }
]

Passing the different options below would yield the following results:

Option	Count	Description
`filteredOut`	0	No records are filtered out
`headersFooters`	2	Group headers have been generated
`collapsed`	0	No groups are collapsed
`visibleData`	3	All data records are "visible"
`all`	5	All options combined

Collapsing the Stockholm group yields the following records in the Store (pseudocode):

store.collapse(store.getAt(3));

[
  { name : 'Group NY', groupHeader : true, expanded : true },
  { id : 1, name : 'Linda', city : 'NY' },
  { id : 2, name : 'Olivia', city : 'NY' },
  { name : 'Group Stockholm', groupHeader : true, expanded : false }
]

Passing the different options below would yield the following results:

Option	Count	Description
`filteredOut`	0	No records are filtered out
`headersFooters`	2	Group headers have been generated
`collapsed`	1	A group with one record is collapsed
`visibleData`	2	Not all data records are "visible"
`all`	5	All options combined

Applying a filter further affects the counts (pseudocode):

store.filter('name', 'Linda');

[
  { name : 'Group NY', groupHeader : true, expanded : true },
  { id : 1, name : 'Linda', city : 'NY' }
]

Passing the different options below would yield the following results:

Option	Count	Description
`filteredOut`	2	Records are filtered out
`headersFooters`	2	Group headers have been generated*
`collapsed`	1	A group with one record is collapsed
`visibleData`	1	Not all data records are "visible"
`all`	5	All options combined

^* Note that also passing filteredOut would include filtered out group headers in the count.

getRange( start, end )
: Model[]

NON-LAZY-LOAD
Store

Creates an array of records from this store from the start to the end - 1
includes( recordOrId )
: Boolean

Store

Checks if the specified record is contained in the store
indexOf( recordOrId, visibleRecordsfalse, allExceptFilteredOutRecordsfalse )
: Number

Store

Returns the index of the specified record/id, or -1 if not found.
isAvailable( recordOrId )
: Boolean

Store

Checks if a record is available, in the sense that it is not filtered out, hidden in a collapsed group or in a collapsed parent node of a tree store.
resumeAutoCommit( )
StoreCRUD

Resumes automatic commits upon store changes. Will trigger commit if the internal counter is 0.
suspendAutoCommit( )
StoreCRUD

Suspends automatic commits upon store changes. Can be called multiple times (it uses an internal counter).
find( fn, searchAllRecords )
: Model

StoreSearch

Finds the first record for which the specified function returns true
findByField( field, value, distinctfalse, searchAllRecordsfalse )
: StoreSearchResult[]

StoreSearch

Find occurrences of the specified value in the specified field on all locally available records in the store
findRecord( fieldName, value, searchAllRecordsfalse )
: Model

StoreSearch

Finds the first record for which the specified field has the specified value
query( fn, searchAllRecords )
: Model[]

StoreSearch

Searches the Store records using the passed function.

search( text, fields, formatters, searchAllRecords )

: StoreSearchResult[]

StoreSearch

Find all hits matching the specified input.

const store = new Store({
  fields : ['name', 'kind'],
  data : [
    { id : 1, name : 'Batman', kind : 'hero' },
    { id : 2, name : 'Batkid', kind : 'hero' },
    { id : 3, name : 'Joker', kind : 'villain' },
    { id : 4, name : 'Penguin', kind : 'villain' }
  ]
});

store.search('villain'); // [{ index : 2, data : joker-record }, { index : 3, data : penguin-record }]

some( fn, searchAllRecords )
: Boolean

StoreSearch

Returns true if the supplied function returns true for any record in the store
addFilter( newFilter, silent )
: Promise/CollectionFilter

ASYNC
StoreFilter

Adds a single filter to the filters collection. By default, filters are reevaluated and a Store change event fired.

If the silent parameter is passed as true, multiple filters can be added without causing data changes.

When the filters are as required, call filter with no parameters to apply the filters to the store.
addGrouper( field, ascendingtrue )
: Promise/null

internal

ASYNC
StoreGroup

Add a grouping level (a grouper).
addSorter( field, ascendingtrue )
: Promise/null

ASYNC
StoreSort

Add a sorting level (a sorter).
clearFilters( silentfalse )
: Promise/null

ASYNC
StoreFilter

Removes all filters from the store. Filters that are marked as internal will not be removed.
clearGroupers( )
: Promise/null

ASYNC

NON-LAZY-LOAD
StoreGroup

Removes all groupers, turning store grouping off.
clearSorters( )
: Promise/null

ASYNC
StoreSort

Removes all sorters, turning store sorting off.
createSorterFn( sorters )
: Function

internal
StoreSparseIndex

Creates a function used with Array#sort when sorting the store. This override adds a sorter on the sparseIndex field if sparse indexes are used and no other sorters are defined.

filter( newFilters )

: Promise/null

ASYNC

StoreFilter

Filters the store by adding the specified filter(s) to the existing filters collection applied to this Store. If a filter has an id specified, or a property specified, it will search for corresponding filter(s) in the existing filters first and replace it with a new filter. It will not remove other filters applied to the store!

To add a new filter:

// Filter using simple object
store.filter({
    property : 'age',
    operator : '>',
    value    : 90
});

// Filter using function
store.filter(r => r.age < 90);

// Filter using a named filter as a function
store.filter({
    id : 'my-filter',
    filterBy : record => record.score > 10
});

To remove a specific filter, but keep other filters applied

// Remove by filter `id` or `property`. Filter `id` defaults to the `property-operator` value.
store.removeFilter('age');
store.removeFilter('my-filter');

To replace all existing filters with a new filter

// Remove all filters and filter using simple object
store.filter({
    filters : {
        property : 'age',
        operator : '<',
        value    : 90
    },
    replace : true
});

// Remove all filters and filter using function
store.filter({
    filters : r => r.age > 90,
    replace : true
});

// Remove all filters and filter using a named filter as a function
store.filter({
    filters : {
        id : 'my-filter',
        filterBy : record => record.score > 10
    },
    replace : true
});

Basically filters replacing is an equivalent of having two sequenced calls: clearFilters and filter.

Call without arguments to reapply filters.

// Re-filter the store
store.filter();

Triggers: filter, change

filterBy( fn )
: Promise/null

ASYNC
StoreFilter
Adds a function used to filter the store. Alias for calling filter(fn). Return true from the function to include record in filtered set
```
store.filterBy(record => record.age > 25 && record.name.startsWith('A'));
```
getGroupRecords( groupValue )
: Model[]

NON-LAZY-LOAD
StoreGroup

Returns all records in the group with specified groupValue.
getGroupTitles( )
: String[]

NON-LAZY-LOAD
StoreGroup

Get all group titles.
group( field, ascending, addfalse, performSorttrue, silentfalse )
: Promise/null

ASYNC

NON-LAZY-LOAD
StoreGroup
Group records, either by replacing current sorters or by adding to them. A grouper can specify a custom sorting function which will be called with arguments (recordA, recordB). Works in the same way as a standard array sorter, except that returning null triggers the stores normal sorting routine. Grouped store must always be sorted by the same field.

To clear groupers and stop grouping, use clearGroupers method.
```
// simple grouper
store.group('city');

// grouper as object, descending order
store.group({ field : 'city', ascending : false });

// using custom sorting function
store.group({
    field : 'city',
    fn : (recordA, recordB) => {
        // apply custom logic, for example:
        return recordA.city.length < recordB.city.length ? -1 : 1;
    }
});

// Stop grouping
store.clearGroupers();
```
Triggers: group, refresh
isRecordInGroup( record, groupValue )
: Boolean

NON-LAZY-LOAD
StoreGroup

Check if a record belongs to a certain group (only for the first grouping level)
performSort( )

private
StoreSort

Perform sorting according to the sorters configured. This is the internal implementation which is overridden in AjaxStore and must not be overridden.

removeFilter( idOrInstance, silentfalse )

: Promise/CollectionFilter

ASYNC

StoreFilter

Removes the passed filter, or the filter by the passed ID from the filters collection. By default, filters are reevaluated and a Store change event fired.

If the silent parameter is passed as true, multiple filters can be removed without causing data changes.

When the filters are as required, call filter with no parameters to apply the filters to the store.

// Only view top priority events
myEventStore.filter({
    id       : 'priorityFilter',
    property : 'priority',
    value    : 1,
    operator : '='
});

// That individual filter can be removed like this
myEventStore.removeFilter('priorityFilter');

// Add named filter as a function
store.filter({
    id : 'my filter',
    filterBy : record => record.score > 10
});

// Remove named filter function
store.removeFilter('my filter');

removeGrouper( field )
: Promise/null

internal

ASYNC
StoreGroup

Removes a grouping level (a grouper)
removeSorter( field )
: Promise/null

ASYNC
StoreSort

Remove a sorting level (a sorter)
setGroupers( groupers )
: Promise/null

ASYNC

NON-LAZY-LOAD
StoreGroup

Set groupers.

sort( field, ascending, addfalse, silentfalse )

: Promise/null

ASYNC

StoreSort

Sort records, either by replacing current sorters or by adding to them. A sorter can specify a custom sorting function which will be called with arguments (recordA, recordB). Works in the same way as a standard array sorter, except that returning null triggers the stores normal sorting routine.

// single sorter
store.sort('age');

// single sorter as object, descending order
store.sort({ field : 'age', ascending : false });

// multiple sorters
store.sort(['age', 'name']);

// using custom sorting function
store.sort((recordA, recordB) => {
    // apply custom logic, for example:
    return recordA.name.length < recordB.name.length ? -1 : 1;
});

// using locale specific sort (slow)
store.sort({ field : 'name', useLocaleSort : 'sv-SE' });

Triggers: beforeSort, sort, refresh

beginBatch( )
Store

Stops this store from firing events until endBatch is called. Multiple calls to beginBatch stack up, and will require an equal number of endBatch calls to resume events.

Upon call of endBatch, a refresh event is triggered to allow UIs to update themselves based upon the new state of the store.

This is extremely useful when making a large number of changes to a store. It is important not to trigger too many UI updates for performance reasons. Batching the changes ensures that UIs attached to this store are only updated once at the end of the updates.
endBatch( )
Store

Ends event suspension started by beginBatch. Multiple calls to beginBatch stack up, and will require an equal number of endBatch calls to resume events.

Upon call of endBatch, a refresh event with action: batch is triggered to allow UIs to update themselves based upon the new state of the store.

This is extremely useful when making a large number of changes to a store. It is important not to trigger too many UI updates for performance reasons. Batching the changes ensures that UIs attached to this store are only updated once at the end of the updates.
load( params )
: Promise

ASYNC
Store

Only available if the store is configured as lazyLoad. Calling will initiate a load request for 1 chunk of records starting from index 0. If the store has previously been loaded, it will be cleared of all records and all lazy loading cache.
onIsCreatingToggle( record, isCreating )

internal
Store

Called by owned record when the record has its isCreating property toggled.
onModelChange( record, toSet, wasSet, silent, fromRelationUpdate )

private
Store

This is called from Model after mutating any fields so that Stores can take any actions necessary at that point, and distribute mutation event information through events.

toJSON( )

: Object[]

Store

Retrieve the data of all (unfiltered) records as an array of JSON objects.

const store = new Store({
    data : [
        { id : 1, name : 'Superman' },
        { id : 2, name : 'Batman' }
    ]
});

const jsonArray = store.toJSON();

//jsonArray:
[{id:1,name:"Superman"},{id:2,name:"Batman"}]

unload( options )
Store

Only available if the store is configured as lazyLoad.

For a flat Store, calling this method will remove the provided records from the store and reload them the next time they are rendered.

For a tree Store, calling this method will remove all child nodes of the provided parent nodes and reload the parent nodes the next time they are rendered or expanded.
acceptChanges( )

internal
StoreCRUD
Accepts all changes, resets the modification tracking:
- Clears change tracking for all records
- Clears added
- Clears modified
- Clears removed Leaves the store in an "unmodified" state.
commitToMaster( )
: Object

internal
StoreChained
Commits changes back to master.
- the records deleted from chained store and present in master will be deleted from master
- the records added to chained store and missing in master will added to master Internally calls {Store#function-commit commit()}.
generateMasterFilterFn( )
: Function

internal
StoreChained

Generates a filter function for filtering which records from the master store should be included in the chained store, based on the master store's filters, if chainFilters is true.

Master store filters flagged with ignoreForChain will be ignored.
onMasterDataChanged( )

private
StoreChained

Handles changes in master stores data. Updates the chained store accordingly
onMasterStoreRefresh( )

private
StoreChained

Handles refresh events from the master store. During batch operations, individual change events are suppressed and only a refresh event with action: 'batch' fires after endBatch(). This ensures the chained store stays in sync after batch operations.
relayToMaster( )

private
StoreChained

Relays some function calls to the master store
filterChangeset( added, updated )
: Object[]

private
StoreChanges
Filters records that have been added/updated as part of a changeset. The added and updated parameters are arrays of values that have already been added/updated in the Collection's values. This method brings the Collection's _filteredValues in sync without performing a full sort or filter, using the following rules:
- Added records that do not match the filter are removed from _filteredValues
- Updated records that now match the filter are inserted at the correct position in _filteredValues if they were not formerly included
- Updated records, which formerly matched the filter, but now do not, are NOT removed from _filteredValues
If the collection is sorted, either on its own or via a sort applied at the store level, that sort order is respected when adding items to _filteredValues. If not, items are inserted in the same order they occur in _values.
filterTreeHierarchyChanges( modifiedParents, record, data )

private
StoreChanges

This method is required to filter out unnecessary orderedParentIndex/parentIndex changes. Those change when we reorder nodes or append new records. If we reorder nodes, we need to apply those changes and then sort the local array according to contents. But if we added nodes, we should ignore such changes in siblings of the added nodes and should recalculate indices right away.
includeInSubset( all, subset, toInclude )
: Array

private
StoreChanges

Given an array all, an array subset that is a subset of all in the same order, and another array toInclude that is a different subset of all disjoint with subset, add each item from toInclude to subset, in an order matching the order in all. The order of subset must match the order of all. The order of toInclude is unimportant.

Modifies subset in-place.
performFilter( )

private
StoreFilter

Perform filtering according to the filters Collection. This is the internal implementation which is overridden in AjaxStore and must not be overridden.
collectGroupRecords( allRecords, includeHeaderstrue )
: Model[]

private
StoreGroup

Collects all group headers + children, whether expanded or not
getGroupHeaderForRecord( targetRecord, ignoreFilterfalse )
: Model

internal
StoreGroup

Returns group header record for the passed record or last group header in the store
cacheRelatedRecord( record, id, name, uncacheId )
: void

private
StoreRelation

Adds a record to relation cache, optionally removing it if already there.
getCollection( record, name )
: Array

private
StoreRelation

Returns records from a collection of related records. Not to be called directly, called from Model getter.
getRelationCollection( name, recordOrId )
: Array

internal
StoreRelation

Returns records the relation cache. Same result as if retrieving the collection on the dependent store, but without the need of accessing that store.
initRelationCollection( config, collectionStore )

private
StoreRelation

Called from other end of a relation when this store should hold a collection of related records.
initRelations( )

private
StoreRelation

Initialized relations, called from constructor
resetRelationCache( )

private
StoreRelation

Updates relationCache for all records.
setCollection( )

private
StoreRelation

Sets a collection of related records. Will updated the related store and trigger events from it. Not to be called directly, called from Model setter.
uncacheRelatedRecord( record, name, id )
: void

private
StoreRelation

Removes a record from relation cache, for a specific relation (specify relation name and id) or for all relations
updateDependentRecordIds( )

private
StoreRelation

Updates relation cache and foreign key value when a related objects id is changed.
updateDependentStores( action, records )

private
StoreRelation

Updates related stores when store is cleared, a record is removed or added.
updateRecordRelationCache( record, relations )
: void

private
StoreRelation

Caches related records from related store on the local store.
performRemoteSort( silent )
: Promise/null

internal

ASYNC
StoreSort

Internal sort method, only called if remoteSort is set on store. Should not be used in application code directly.
add( records, silentfalse, options )
: Model[]

internal
StoreSparseIndex

Wrapper for StoreCRUD.add, adding sparse indexes to appended records
initSparseIndexes( event )

internal
StoreSparseIndex

Initialize sparse indexes for existing records which don't have a sparseIndex value. If the store is not sorted, it will first be sorted by sparseIndex; records without one are sorted to the end. After all records have a sparseIndex value, the values will be consolidated to ensure that no duplicates exist.
insert( index, records, silentfalse )
: Model[]

internal
StoreSparseIndex

Wrapper for StoreCRUD.insert, adding sparse indexes to inserted records
move( records, beforeRecord, silentfalse )
: void

internal
StoreSparseIndex

Wrapper for StoreCRUD.move, adding sparse indexes to inserted records
remove( records, silentfalse )
: Model[]

internal
StoreSparseIndex

Wrapper for StoreCRUD.remove, clearing sparse indexes on removed records
applyState( state )

private
StoreState

Apply store state. Used by State-plugin to restore a previously serialized state
getState( )
: Object

private
StoreState

Get store state. Used by State-plugin to serialize state
syncDataset( data )

private
StoreSync
Syncs a new dataset against the already loaded one, only applying changes. Not intended to be called directly, please configure store with syncDataOnLoad: true and assign to store.data as usual instead.
```
const store = new Store({
   syncDataOnLoad : true,
   data : [
       // initial data
   ]
});

store.data = [ // new data ]; //  Difference between initial data and new data will be applied
```
transformToTree( data )
: Object[]

private
StoreTree

Transforms flat data containing parent ids into tree data
treeify( fields, parentTransform, convertParentsfalse )
: Model

internal
StoreTree
Transforms this store data into a tree with parent levels based on supplied fields.
```
const newRoot = store.treeify(['name', r => r.age % 10]);
```
Generated parent records are indicated with generatedParent and key properties. The first one is set to true and the latter one has a value for the group the parent represents.
treeifyData( fields, parentTransform, convertParentsfalse )
: Model

internal
StoreTree
Transforms passed data into a tree with parent levels based on supplied fields.
```
const newRoot = store.treeify(
    [
        { name : "Julia", age : 21 },
        { name : "Macie", age : 12 },
        { name : "Julia", age : 18 },
        { name : "Olivia", age : 8 },
    ],
    ['name', r => r.age % 10]
);
```
Generated parent records are indicated with generatedParent and key properties. The first one is set to true and the latter one has a value for the group the parent represents.
average( field, records )
: Number

StoreSum

Returns the average value for the specified field. Defaults to look through all locally available records in store
groupSum( groupValue, field )
: Number

NON-LAZY-LOAD
StoreSum

Returns sum by adding value of specified field for records in the group with the specified groupValue.
max( field, records )
: Number/Date

StoreSum

Returns max value for the specified field, can be used with Date or Number values. Defaults to look through all locally available records in store
min( field, records )
: Number/Date

StoreSum

Returns min value for the specified field, can be used with Date or Number values. Defaults to look through all locally available records in store
sum( field, records )
: Number

StoreSum

Returns sum calculated by adding value of specified field for specified records. Defaults to using all locally available records in store
getAdjacent( recordOrId, nexttrue, wrapfalse, skipSpecialRowsfalse )
: Model

internal
Store

Gets the next or the previous record locally available. Optionally wraps from first -> last and vice versa
getAdjacentLeaf( recordOrId, nexttrue, wrapfalse )
: Model

internal
Store

Gets the next or the previous record among leaves (in a tree structure). Optionally wraps from first -> last and vice versa
getNext( recordOrId, wrapfalse, skipSpecialRowsfalse )
: Model

Store

Finds the next record locally available.
getNextLeaf( recordOrId, wrapfalse )
: Model

internal
Store

Finds the next record among leaves (in a tree structure)
getPrev( recordOrId, wrapfalse, skipSpecialRowsfalse )
: Model

Store

Finds the previous record locally available.
getPrevLeaf( recordOrId, wrapfalse )
: Model

internal
Store

Finds the previous record among leaves (in a tree structure)
traverse( fn, topNodethis.rootNode, skipTopNode, options )

NON-LAZY-LOAD
Store

Traverse all tree nodes (only applicable for Tree Store)
traverseWhile( fn, topNodethis.rootNode, skipTopNode, options )

NON-LAZY-LOAD
Store

Traverse all tree nodes while the passed fn returns true
getChildren( parent )
: Model[]

StoreTree

Returns the children of the passed branch node which this store owns. By default, this is the entire children array.

If this store isChained, then this returns only the subset of children which are filtered into this store by the chainedFilterFn.
indent( nodes )
: Promise

ASYNC

NON-LAZY-LOAD
StoreTree

Increase the indentation level of one or more nodes in the tree

Triggers: indent, change
internalToggleTreeSubRecords( parent, include )
: void

private
StoreTree

Includes or excludes all records beneath parentRecord in storage. Used when expanding or collapsing nodes.
loadChildren( parentRecord )
: Promise

ASYNC
StoreTree

Loads children for a parent node that uses load on demand (when expanding it). Base implementation does nothing, either use AjaxStore which implements it, create your own subclass with an implementation or listen for toggleNode and insert records when you have them available.
onNodeAddChild( parent, children, index, isMove, silentfalse )

internal
StoreTree

Called from Model when adding children. Not to be called directly, use Model#appendChild() instead.

Triggers: add, change
onNodeCollapse( parentRecord )
: void

private
StoreTree

Remove all records beneath parentRecord from storage.
onNodeExpand( parentRecord )
: void

private
StoreTree

Add all records beneath parentRecord from storage.
outdent( nodes )
: Promise

ASYNC

NON-LAZY-LOAD
StoreTree

Decrease the indentation level of one or more nodes in the tree

Triggers: outdent, change
toggleCollapse( idOrRecord, collapse )
: Promise

ASYNC
StoreTree

Collapse an expanded record or expand a collapsed. Optionally forcing a certain state.
getDistinctValues( field, includeFilteredOutRecordsfalse, includeCountsfalse )
: Array

Store
Returns an array of distinct values from all locally available records for the specified field.
```
store.getDistinctValues('age'); // Returns an array of the unique age values
```
getValueCount( field, value )
: Number

Store

Counts how many times the specified value appears locally in the store

Events

Events are triggered for certain actions in this class and can be listened for to react to those actions in your code

add
StoreCRUD

Fired after adding/inserting record(s). If the record was added to a parent, the isChild flag is set on the event. If it was inserted, event contains index
addConfirmed
Store

Fired when a temporary record with the isCreating property set has been confirmed as a part of this store by having its isCreating property cleared.
afterRequest
Store

Fired after any remote request has finished whether successfully or unsuccessfully.
batchedUpdate

private
Store

Fired when one of this Store's constituent records is modified while in batched state. This may be used to keep UIs up to date while "tentative" changes are made to a record which must not be synced with a server.
beforeAdd

PREVENTABLE
StoreCRUD

Fired before records are added to this store by the add or insert. In a tree store, also fired by appendChild and insertChild. The add or insert may be vetoed by returning false from a handler.
beforeCommit
StoreCRUD

Fired before committing changes. Return false from handler to abort commit
beforeDestroy
Events

Fires before an object is destroyed.
beforeFilter
StoreFilter

Fired before filtering
beforeIndent

PREVENTABLE
StoreTree

Fired before nodes in the tree are indented. Return false from a listener to prevent the indent.
beforeLoadPage

PREVENTABLE
StorePaging

When the store is paged, this is fired before loading a page and is cancelable
beforeOutdent

PREVENTABLE
StoreTree

Fired before nodes in the tree are outdented. Return false from a listener to prevent the outdent.
beforeRemove

PREVENTABLE
StoreCRUD

Fired before records are removed from this store by the remove or removeAll. Also fired when removing a child record in a tree store using removeChild. The remove may be vetoed by returning false from a handler.
beforeRequest

ASYNC

PREVENTABLE
Store

Fired before any remote request is initiated.
beforeSort
StoreSort

Fired before sorting
beforeUpdate
Store

Fired before record is modified in this store. Modification may be vetoed by returning false from a handler.
beginDataUpdate

internal
Store

Fired when the store is about to perform an expensive batch data operation.

This event is intended to let listeners suspend expensive processing (such as UI refreshes) until the corresponding endDataUpdate event is fired.
catchAll
Events

Fires when any other event is fired from the object.

Note: catchAll is fired for both public and private events. Please rely on the public events only.
change
StoreCRUD

Fired when Data in the store was changed. See change event for the details.
commit
StoreCRUD

Fired after committing changes
destroy
Events

Fires when an object is destroyed.
endDataUpdate

internal
Store

Fired after a store has finished an expensive batch data operation.

Intended to pair with beginDataUpdate so listeners can resume processing and perform a single refresh after the batch completes.
filter
StoreFilter

Fired after applying filters to the store
formulaError

internal
Store

Fired when a formula defined on a datafield fails to evaluate.
group
StoreGroup

Fired when grouping changes
idChange
Store

Fired when the id of a record has changed
indent
StoreTree

Fired after tasks in the tree are indented
loadPage
StorePaging

When the store is paged, this is fired when a page is loaded.
move
Store

Fired when a block of records has been moved within this Store
outdent
StoreTree

Fired after tasks in the tree are outdented
refresh
StoreCRUD

Data in the store has completely changed, such as by a filter, or sort or load operation.
remove
StoreCRUD

Fired when one or more records are removed
removeAll
StoreCRUD

Fired after removing all records
requestData
Store

This event only fires in a non-AjaxStore, configured with remoteSort, remoteFilter or remotePaging, when the Store requests more or new data.

The event will contain same params as described in the requestData function. This event can be listened to if you want to receive notifications about the Store's data requests, but not directly want to return the requested data. For example, when you got the Store's data bound to a data source with the help of an external library/framegrunt docswork.
rootChange
Store

Fired when the root node is set
sort
StoreSort

Fired after sorting
update
Store

Fired when a record is modified

Event handlers

Event handlers are callbacks called as a result of certain actions in this class

onAdd
StoreCRUD

Called after adding/inserting record(s). If the record was added to a parent, the isChild flag is set on the event. If it was inserted, event contains index
onAddConfirmed
Store

Called when a temporary record with the isCreating property set has been confirmed as a part of this store by having its isCreating property cleared.
onAfterRequest
Store

Called after any remote request has finished whether successfully or unsuccessfully.
onBatchedUpdate

private
Store

Called when one of this Store's constituent records is modified while in batched state. This may be used to keep UIs up to date while "tentative" changes are made to a record which must not be synced with a server.
onBeforeAdd

PREVENTABLE
StoreCRUD

Called before records are added to this store by the add or insert. In a tree store, also called by appendChild and insertChild. The add or insert may be vetoed by returning false from a handler.
onBeforeCommit
StoreCRUD

Called before committing changes. Return false from handler to abort commit
onBeforeDestroy
Events

Called before an object is destroyed.
onBeforeFilter
StoreFilter

Called before filtering
onBeforeIndent

PREVENTABLE
StoreTree

Called before nodes in the tree are indented. Return false from a listener to prevent the indent.
onBeforeLoadPage

PREVENTABLE
StorePaging

When the store is paged, this is called before loading a page and is cancelable
onBeforeOutdent

PREVENTABLE
StoreTree

Called before nodes in the tree are outdented. Return false from a listener to prevent the outdent.
onBeforeRemove

PREVENTABLE
StoreCRUD

Called before records are removed from this store by the remove or removeAll. Also called when removing a child record in a tree store using removeChild. The remove may be vetoed by returning false from a handler.
onBeforeRequest

ASYNC

PREVENTABLE
Store

Called before any remote request is initiated.
onBeforeSort
StoreSort

Called before sorting
onBeforeUpdate
Store

Called before record is modified in this store. Modification may be vetoed by returning false from a handler.
onBeginDataUpdate

internal
Store

Called when the store is about to perform an expensive batch data operation.

This event is intended to let listeners suspend expensive processing (such as UI refreshes) until the corresponding endDataUpdate event is called.
onCatchAll
Events

Called when any other event is called from the object.

Note: catchAll is called for both public and private events. Please rely on the public events only.
onChange
StoreCRUD

Called when Data in the store was changed. See change event for the details.
onCommit
StoreCRUD

Called after committing changes
onDestroy
Events

Called when an object is destroyed.
onEndDataUpdate

internal
Store

Called after a store has finished an expensive batch data operation.

Intended to pair with beginDataUpdate so listeners can resume processing and perform a single refresh after the batch completes.
onFilter
StoreFilter

Called after applying filters to the store
onFormulaError

internal
Store

Called when a formula defined on a datafield fails to evaluate.
onGroup
StoreGroup

Called when grouping changes
onIdChange
Store

Called when the id of a record has changed
onIndent
StoreTree

Called after tasks in the tree are indented
onLoadPage
StorePaging

When the store is paged, this is called when a page is loaded.
onMove
Store

Called when a block of records has been moved within this Store
onOutdent
StoreTree

Called after tasks in the tree are outdented
onRefresh
StoreCRUD

Data in the store has completely changed, such as by a filter, or sort or load operation.
onRemove
StoreCRUD

Called when one or more records are removed
onRemoveAll
StoreCRUD

Called after removing all records
onRequestData
Store

This event only fires in a non-AjaxStore, configured with remoteSort, remoteFilter or remotePaging, when the Store requests more or new data.

The event will contain same params as described in the requestData function. This event can be listened to if you want to receive notifications about the Store's data requests, but not directly want to return the requested data. For example, when you got the Store's data bound to a data source with the help of an external library/framegrunt docswork.
onRootChange
Store

Called when the root node is set
onSort
StoreSort

Called after sorting
onUpdate
Store

Called when a record is modified

Source path

SchedulerPro/data/VersionStore.js

VersionStore

See also

Configs

Handlers as function name

Parameters

Returns

Threshold

Missing fields

`changes` behavior

Parameters

Parameters

Returns

Parameters

Returns

Parameters

Returns

Properties

Resolving a value from an owner

Value Merging

Config Options

Default Value

`changes` behavior

Functions

Phantom ids

Transforming a response to the correct format

Preventing automatic commit of applied changes

Events

Event handlers

Source path

Inheritance tree3

Mixins16

Contents

VersionStore

See also

Configs

Handlers as function name

Parameters

Returns

Threshold

Missing fields

changes behavior

Parameters

Parameters

Returns

Parameters

Returns

Parameters

Returns

Properties

Resolving a value from an owner

Value Merging

Config Options

Default Value

changes behavior

Functions

Phantom ids

Transforming a response to the correct format

Preventing automatic commit of applied changes

Events

Event handlers

Source path

Inheritance tree3

Mixins16

Contents

`changes` behavior

`changes` behavior