CalendarManagerStore

A tree store that manages the hierarchy of calendars available in a Scheduler Pro project. Each calendar is represented as a CalendarModel instance, and the store expects hierarchical data where parent nodes contain their children in a property called children.

Calendars define the working time rules for the project, individual resources, and events. The store is automatically created and populated by the project and can be accessed via project.calendarManagerStore. It also provides built-in validation to verify that calendar data is compatible with the CalendarEditor.

Please refer to the calendars guide for details.

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.
autoCommitTimeout : Number10
AjaxStore

The timeout in milliseconds to wait before persisting changes to the server. Used when autoCommit is set to true.
autoLoad : Boolean
AjaxStore

True to initiate a load when the store is instantiated
data : Object[]/Model[]

NON-LAZY-LOAD
AjaxStore
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)[]
AjaxStore
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
AjaxStore

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

AjaxStore

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
AjaxStore
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)
loadPriority : Number

private

CrudManager must load stores in the correct order. Lowest first.
syncPriority : Number

private

CrudManager must sync stores in the correct order. Lowest first.
allowNoId : Booleantrue
AjaxStore

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
AjaxStore

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
AjaxStore

A Collection, or Collection config object to use to contain this Store's constituent records.
storeClass : Class
AjaxStore
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
AjaxStore
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.
ignoreLoadPropagationChanges : Boolean
AjaxStore

This config is taken into account only when store is part of a scheduling project.

If such store loads data via readUrl, automatic calculation of the schedule after the load might lead to some data modifications (for example if syncDataOnLoad is enabled). Such modifications will then be submitted back to the server, which might not be needed, since the data is already coming from the server.

Enabling this config will ignore data modifications during the propagation stage and nothing will be submitted to server.

transformCreationData : Function

AjaxStore

Pass a function to transform record creation data before it is sent to the backend

new AjaxStore({
     transformCreationData : payload => {
         // Transform the data and return the payload
         for (const creationData of payload.data) {
             creationData.timestamp = Date.now();
         }

         return payload;
     }
});

Parameters

payload : Object
Payload
data : Array

The data that is going to be sent to the backend

Returns

Object

Return the modified payload

transformLoadedData : Function
AjaxStore
Pass a function to transform data loaded from the backend before it is turned into records and added to the store
```
new AjaxStore({
     transformLoadedData : response => {
         // Transform the loaded data and return the response object
     }
});
```
Parameters
- response : Object
  Response
- data : Array
  
  The data that is going to be loaded into the store
Returns

Object
:

Returns the modified response object

transformModificationData : Function

AjaxStore

Pass a function to transform records modification data before it is sent to the backend

new AjaxStore({
     transformModificationData : payload => {
         // Transform the data and return the payload
         for (const recordData of payload.data) {
             // Some kind of transformation here...
             if (recordData.ignore) {
                 ArrayHelper.remove(payload.data, recordData);
             }
         }

         return payload;
     }
});

Parameters

payload : Object
Payload
data : Array

The data that is going to be sent to the backend

Returns

Object

Return the modified payload

transformRemovalData : Function

AjaxStore

Pass a function to transform record removal data before it is sent to the backend

new AjaxStore({
     transformRemovalData : payload => {
         // Transform the data and return the payload
         const transformedData = {};
         for (const id of payload.ids) {
             transformedData[id] = true;
         }
         payload.ids = transformedData;

         return payload;
     }
});

Parameters

payload : Object
Payload
ids : Array

Ids for records being removed

Returns

Object

Return the modified payload

createUrl : String
AjaxStore
Url to post newly created records to.

The response must be in the form:
```
{
    "success": true,
    "data": [{
        "id": 0, "name": "General Motors"
    }, {
        "id": 1, "name": "Apple"
    }]
}
```
Just the array of data may be returned, however that precludes the orderly handling of errors encountered at the server.

If the server encountered an error, the packet would look like this:
```
{
    "success": false,
    "message": "Some kind of database error"
}
```
And that packet would be available in the exception handler in the response property of the event.

The success property may be omitted, it defaults to true.

Has a corresponding runtime createUrl property.
deleteUrl : String
AjaxStore
Url for deleting records.

The response must be in the form:
```
{
    "success": true
}
```
If the server encountered an error, the packet would look like this:
```
{
    "success": false,
    "message": "Some kind of database error"
}
```
And that packet would be available in the exception handler in the response property of the event.

The success property may be omitted, it defaults to true.

Has a corresponding runtime deleteUrl property.
readUrl : String
AjaxStore
Url to read data from.

The response must be in the form:
```
{
    "success": true,
    "data": [{
        "id": 0, "name": "General Motors"
    }, {
        "id": 1, "name": "Apple"
    }]
}
```
If the store is paged, the total dataset size must be returned in the responseTotalProperty property:
```
{
    "success": true,
    "data": [{
        "id": 0, "name": "General Motors"
    }, {
        "id": 1, "name": "Apple"
    }],
    "total": 65535
}
```
Just the array of data may be returned, however that precludes the orderly handling of errors encountered at the server.

If the server encountered an error, the packet would look like this:
```
{
    "success": false,
    "message": "Some kind of database error"
}
```
And that packet would be available in the exception handler in the response property of the event.

The success property may be omitted, it defaults to true.

Has a corresponding runtime readUrl property.
updateUrl : String
AjaxStore
Url to post record modifications to.

The response must be in the form:
```
{
    "success": true,
    "data": [{
        "id": 0, "name": "General Motors"
    }, {
        "id": 1, "name": "Apple"
    }]
}
```
Just the array of data may be returned, however that precludes the orderly handling of errors encountered at the server.

If the server encountered an error, the packet would look like this:
```
{
    "success": false,
    "message": "Some kind of database error"
}
```
And that packet would be available in the exception handler in the response property of the event.

The success property may be omitted, it defaults to true.

Has a corresponding runtime updateUrl property.
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.
taskStore : EventStore/EventStoreConfig
PartOfProject

An EventStore instance or a config object.

Has a corresponding runtime taskStore 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
AjaxStore
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
fetchOptions : Object
AjaxStore
An object containing the Fetch options to pass to each server request issued by this store. Use this to control if credentials are sent and other options, read more at MDN.

Example usage:
```
const store = new AjaxStore({
   fetchOptions : {
       credentials : 'omit',
       redirect    : 'error'
   }
});
```
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.
headers : Object<String, String>
AjaxStore
A string keyed object containing the HTTP headers to add to each server request issued by this store.

AjaxStore uses the Fetch API under the hood, read more about headers on MDN

Example usage:
```
const store = new AjaxStore({
   headers : {
       Authorization : 'auth-contents-goes-here'
   }
});
```

httpMethods : HttpMethods{"create":"POST","read":"GET","update":"PUT","delete":"DELETE"}

AjaxStore

The HTTP methods to use for CRUD requests when useRestfulMethods is enabled.

new AjaxStore({
   useRestfulMethods : true,
   httpMethods : {
       create : 'POST',
       read   : 'POST',
       update : 'PATCH',
       delete : 'DELETE'
   }
});

params : Object
AjaxStore

An object containing key/value pairs that are passed on the request query string, or in the request body if HTTP method allows. See paramsInBody config.

Has a corresponding runtime params property.
paramsInBody : Booleantrue
AjaxStore

When this config is enabled, the params of "read" request are placed in the request body instead of the query string, if the HTTP method allows.
parentIdParamName : Stringid
AjaxStore

The name of the HTTP parameter passed to this Store's readUrl to indicate the node id to load when loading child nodes on demand if the node being expanded was created with data containing children: true.
responseDataProperty : Stringdata
AjaxStore
The property name in JSON responses from the server that contains the data for the records
```
{
  "success" : true,
  // The property name used here should match that of 'responseDataProperty'
  "data" : [
    ...
  ]
}
```

responseSuccessProperty : Stringsuccess

AjaxStore

The optional property name in JSON responses from the server that contains a boolean success/fail status.

{
  "responseMeta" : {
  {
    "success" : true,
    "count" : 100
  },
  // The property name used here should match that of 'responseDataProperty'
  "data" : [
    ...
  ]
}

The store would be configured with:

 {
     ...
     successDataProperty : 'responseMeta.success',
     responseTotalProperty : 'responseMeta.count'
     ...
 }

responseTotalProperty : Stringtotal

AjaxStore

The property name in JSON responses from the server that contains the dataset total size when this store is paged or lazy loaded

{
  "success" : true,
  // The property name used here should match that of 'responseDataProperty'
  "data" : [
    ...
  ],
  // The property name used here should match that of 'responseTotalProperty'
  "total" : 65535
}

restfulFilter : Boolean
AjaxStore

Set this flag to true if you are filtering remote using restful URLs (e.g. https://nominatim.openstreetmap.org/search/paris?format=json)

Note: When this is set, the filter string is appended to the readUrl.
sendAsFormData : Booleanfalse
AjaxStore

Specify true to send payloads as form data, false to send as regular JSON.
useRestfulMethods : Booleanfalse
AjaxStore

Set to ´true´ to use restful httpMethods
writeAllFields : Booleanfalse
AjaxStore

Specify true to send all model fields when committing modified records (as opposed to just the modified fields)
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
AjaxStore

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
AjaxStore

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).
includeChildrenInRemoveRequest : Booleantrue
AjaxStore
Set to false to only include the id of a removed parent node in the request to the backend, and not the ids of its children. Applies when configured with a deleteUrl.

Consider the following scenario, removing parent 1:
```
{
  id : 1,
  children : [
    { id : 11 },
    { id : 12 }
  ]
}
```
With includeChildrenInRemoveRequest : false, the backend will only receive the removal of id 1.

With includeChildrenInRemoveRequest : true (the default), the backend will receive the removal of id 1, 11 and 12.

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
AjaxStore

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

isCalendarManagerStore : Booleantrue

READONLY

static

ADVANCED

Identifies an object as an instance of CalendarManagerStore class, or subclass thereof.
isEvents : Booleantrue

READONLY

static

ADVANCED
Events

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

READONLY

static

ADVANCED
PartOfProject

Identifies an object as an instance of PartOfProject 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.
configurable : Object

internal

static
AjaxStore
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
AjaxStore
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
AjaxStore
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
AjaxStore

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

internal

READONLY

static
AjaxStore
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
AjaxStore

Get all registered stores

id : String/Number

READONLY
AjaxStore

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
AjaxStore

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
AjaxStore

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

internal

READONLY
AjaxStore

An empty object that can be used as a default value.
createUrl : String
AjaxStore
Url to post newly created records to.

The response must be in the form:
```
{
    "success": true,
    "data": [{
        "id": 0, "name": "General Motors"
    }, {
        "id": 1, "name": "Apple"
    }]
}
```
Just the array of data may be returned, however that precludes the orderly handling of errors encountered at the server.

If the server encountered an error, the packet would look like this:
```
{
    "success": false,
    "message": "Some kind of database error"
}
```
And that packet would be available in the exception handler in the response property of the event.

The success property may be omitted, it defaults to true.

Has a corresponding createUrl config.
deleteUrl : String
AjaxStore
Url for deleting records.

The response must be in the form:
```
{
    "success": true
}
```
If the server encountered an error, the packet would look like this:
```
{
    "success": false,
    "message": "Some kind of database error"
}
```
And that packet would be available in the exception handler in the response property of the event.

The success property may be omitted, it defaults to true.

Has a corresponding deleteUrl config.
isCommitting : Boolean

READONLY
AjaxStore

Returns true if the Store is currently committing
isLoading : Boolean/Number

READONLY
AjaxStore

Returns a truthy value if the Store is currently loading.

A load operation is initiated by a load call, but the network request is not sent until after a delay until the next event loop because of allowing all operations which may request a load to coalesce into one call.

If the loading request is in this waiting state, the value will be 1,

If the network request is in flight, the value will be 2
readUrl : String
AjaxStore
Url to read data from.

The response must be in the form:
```
{
    "success": true,
    "data": [{
        "id": 0, "name": "General Motors"
    }, {
        "id": 1, "name": "Apple"
    }]
}
```
If the store is paged, the total dataset size must be returned in the responseTotalProperty property:
```
{
    "success": true,
    "data": [{
        "id": 0, "name": "General Motors"
    }, {
        "id": 1, "name": "Apple"
    }],
    "total": 65535
}
```
Just the array of data may be returned, however that precludes the orderly handling of errors encountered at the server.

If the server encountered an error, the packet would look like this:
```
{
    "success": false,
    "message": "Some kind of database error"
}
```
And that packet would be available in the exception handler in the response property of the event.

The success property may be omitted, it defaults to true.

Has a corresponding readUrl config.
updateUrl : String
AjaxStore
Url to post record modifications to.

The response must be in the form:
```
{
    "success": true,
    "data": [{
        "id": 0, "name": "General Motors"
    }, {
        "id": 1, "name": "Apple"
    }]
}
```
Just the array of data may be returned, however that precludes the orderly handling of errors encountered at the server.

If the server encountered an error, the packet would look like this:
```
{
    "success": false,
    "message": "Some kind of database error"
}
```
And that packet would be available in the exception handler in the response property of the event.

The success property may be omitted, it defaults to true.

Has a corresponding updateUrl config.
isAjaxStore : Booleantrue

READONLY

ADVANCED
AjaxStore

Identifies an object as an instance of AjaxStore class, or subclass thereof.
isCalendarManagerStore : Booleantrue

READONLY

ADVANCED

Identifies an object as an instance of CalendarManagerStore class, or subclass thereof.
isStore : Booleantrue

READONLY

ADVANCED
AjaxStore

Identifies an object as an instance of Store 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
AjaxStore

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

READONLY

ADVANCED
AjaxStore

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

READONLY
AjaxStore

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
AjaxStore

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.
assignmentStore : AssignmentStore

READONLY
PartOfProject

Returns the assignment store of the project this entity belongs to.
calendarManagerStore : CalendarManagerStore

READONLY
PartOfProject

Returns the calendar manager store of the project this entity belongs to.
dependencyStore : DependencyStore

READONLY
PartOfProject

Returns the dependency store of the project this entity belongs to.
eventStore : EventStore

READONLY
PartOfProject

Returns the task store of the project this entity belongs to.
resourceStore : ResourceStore

READONLY
PartOfProject

Returns the resource store of the project this entity belongs to.
taskStore : EventStore

READONLY
PartOfProject

The store holding data on events.

Has a corresponding taskStore 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.
project : ProjectModel

READONLY
PartOfProject

Returns the project this entity belongs to.
allRecords : Model[]

READONLY
AjaxStore

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

AjaxStore

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
AjaxStore
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
AjaxStore

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
AjaxStore

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

Class used to represent records. Defaults to class Model.

Has a corresponding modelClass config.
records : Model[]

READONLY

IMMUTABLE
AjaxStore

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

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.
params : Object
AjaxStore

An object containing key/value pairs that are passed on the request query string, or in the request body if HTTP method allows. See paramsInBody config.

Has a corresponding params config.
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
AjaxStore

Pretty printed version of json

json : String

NON-LAZY-LOAD

AjaxStore

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
AjaxStore

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
AjaxStore

The invisible root node of this tree.

Functions

Functions are methods available for calling on the class

hasConfigPath( object, path )
: Boolean

internal

static
AjaxStore

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

internal

static
AjaxStore

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

private

static
AjaxStore

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

internal

static
AjaxStore

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

static

ADVANCED
AjaxStore
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
AjaxStore

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
AjaxStore

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

static

ADVANCED
AjaxStore
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
AjaxStore

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

static

ADVANCED
AjaxStore

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
AjaxStore
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
AjaxStore

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

AjaxStore

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
AjaxStore
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
AjaxStore

Base constructor, passes arguments to construct.
validateAllRecordsForCalendarEditor( )

Validate all the registered calendars ability to be edited with the calendar editor. If there are any errors they are reported as warnings in the browser console.
validateRecordForCalendarEditor( calendar )

Validates if the provided calendar data can be loaded by the calendar editor. If there are any errors they are reported as warnings in the browser console.
commitAdded( commitState )
: Promise/null

private

ASYNC
AjaxStore

Commits added records by posting to createUrl. Server should return a JSON object with a 'success' property indicating whether the operation was successful.

Triggers: beforeRequest, commitAdded, refresh, exception, afterRequest
commitModified( commitState )
: Promise/null

private

ASYNC
AjaxStore

Commits modified records by posting to updateUrl. Server should return a JSON object with a 'success' property indicating whether the operation was successful.

Triggers: beforeRequest, commitModified, refresh, exception, afterRequest
commitRemoved( commitState )
: Promise/null

private

ASYNC
AjaxStore

Commits removed records by posting to deleteUrl. Server should return a JSON object with a 'success' property indicating whether the operation was successful.

Triggers: beforeRequest, commitRemoved, refresh, exception, afterRequest

encodeFilterParams( filters )

AjaxStore

A provided function which creates an array of values for the filterParamName to pass any filters to the server upon load.

By default, this creates a JSON string containing the following properties:

   [{
       field         : <theFieldName>
       operator      : May be: `'='`, `'!='`, `'>'`, `'>='`, `'<'`, `'<='`, `'*'`, `'startsWith'`, `'endsWith'`
       value         : The value to compare
       caseSensitive : true for case sensitive comparisons
   }]

encodeSorterParams( sorters )
AjaxStore
A provided function which creates an array of values for the {#config-sortParamName} to pass any sorters to the server upon load.
By default, this creates a JSON string containing the following properties:
```
   [{
       field     : <theFieldName>
       ascending : true/false
   }]
```
internalLoad( )
: Promise
internal
ASYNC
AjaxStore
Internal data loading method.
performCommit( )
: Promise
internal
ASYNC
AjaxStore
Internally used to perform the actual commit without any queue handling or timeout
performRemoteFilter( silent )
: Promise/null
internal
ASYNC
AjaxStore
Internal filter method. Should not be used in application code directly.
queueCommit( )
: Promise
internal
ASYNC
AjaxStore
Internally used to handle the commit queue
unload( options )
AjaxStore
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.
_thisIsAUsedExpression( expression )
internal
AjaxStore
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
AjaxStore
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
AjaxStore
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
AjaxStore
Returns true if this instance has a non-null value for the specified config. This will not activate a lazy config.
peekConfig( name )
: *
internal
AjaxStore
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
AjaxStore
Tracks a detacher function for the specified listener name.
triggerConfig( name )
: Boolean
internal
AjaxStore
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
AjaxStore
This call will activate any pending lazy configs that were assigned a string value equal to the group parameter.
untrackDetachers( eventer )
private
AjaxStore
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
AjaxStore
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
load( params )
: Promise
ASYNC
AjaxStore
Load data from the readUrl. If configured as lazyLoad, this will load 1 chunk of records starting from index 0. If the store has previously been loaded, it will first be cleared of all records and all lazy load cache.

Triggers: beforeLoad, loadStart, beforeRequest, load, exception, afterRequest
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
AjaxStore
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
AjaxStore
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
AjaxStore
Gets the full properties block for this class's entire inheritance chain all the way up to but not including Base
onConfigChange( info )
internal
AjaxStore
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
AjaxStore
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
AjaxStore
Equivalent to Array.every(). Returns true if every call of the provided function on each record yields a truthy value.
flatMap( fn, thisObj )
: Array
AjaxStore
Equivalent to Array.flatMap(). Creates a new array by spreading the results of calling a provided function on every record
forEach( fn, thisObj, options )
AjaxStore
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
AjaxStore
Equivalent to Array.map(). Creates a new array with the results of calling a provided function on every record
reduce( fn, initialValue, thisObj )
: *
AjaxStore
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
AjaxStore
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
AjaxStore
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
AjaxStore
Called by the Base constructor to apply configs to this instance. This must not be called.
construct( ...args )
ADVANCED
AjaxStore
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
AjaxStore
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
AjaxStore
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
AjaxStore
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
AjaxStore
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' )
AjaxStore
Changes the value of a numeric property of this object smoothly over the specified duration.
callback( fn, thisObject, args )
ADVANCED
AjaxStore
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( )
AjaxStore
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
AjaxStore
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
AjaxStore
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
AjaxStore
Get the record at the specified index.
getById( id )
: Model
AjaxStore
Get a locally available record by id. Find the record even if filtered out, part of collapsed group or collapsed node
getByIds( recordsOrIds )
: Model[]
AjaxStore
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
AjaxStore
Get a record by internalId.

getCount( optionstrue )

: Number

AjaxStore

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
AjaxStore
Creates an array of records from this store from the start to the end - 1
includes( recordOrId )
: Boolean
AjaxStore
Checks if the specified record is contained in the store
indexOf( recordOrId, visibleRecordsfalse, allExceptFilteredOutRecordsfalse )
: Number
AjaxStore
Returns the index of the specified record/id, or -1 if not found.
isAvailable( recordOrId )
: Boolean
AjaxStore
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( )
AjaxStore
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( )
AjaxStore
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.
onIsCreatingToggle( record, isCreating )
internal
AjaxStore
Called by owned record when the record has its isCreating property toggled.
onModelChange( record, toSet, wasSet, silent, fromRelationUpdate )
private
AjaxStore
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[]

AjaxStore

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"}]

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
AjaxStore
Gets the next or the previous record locally available. Optionally wraps from first -> last and vice versa
getAdjacentLeaf( recordOrId, nexttrue, wrapfalse )
: Model
internal
AjaxStore
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
AjaxStore
Finds the next record locally available.
getNextLeaf( recordOrId, wrapfalse )
: Model
internal
AjaxStore
Finds the next record among leaves (in a tree structure)
getPrev( recordOrId, wrapfalse, skipSpecialRowsfalse )
: Model
AjaxStore
Finds the previous record locally available.
getPrevLeaf( recordOrId, wrapfalse )
: Model
internal
AjaxStore
Finds the previous record among leaves (in a tree structure)
traverse( fn, topNodethis.rootNode, skipTopNode, options )
NON-LAZY-LOAD
AjaxStore
Traverse all tree nodes (only applicable for Tree Store)
traverseWhile( fn, topNodethis.rootNode, skipTopNode, options )
NON-LAZY-LOAD
AjaxStore
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
AjaxStore
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
AjaxStore
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
AjaxStore
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
AjaxStore
Fired after any remote request has finished whether successfully or unsuccessfully.
batchedUpdate
private
AjaxStore
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.
beforeLoad
PREVENTABLE
AjaxStore
Fired before loading starts. Allows altering parameters and is cancelable by returning false. For paged stores, instead listen to beforeLoadPage. For remote loading of tree child nodes, listen to beforeLoadChildren.
beforeLoadChildren
PREVENTABLE
AjaxStore
Fired before loading of remote child nodes of a tree node starts. Allows altering parameters and is cancelable
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
AjaxStore
Fired before any remote request is initiated.
beforeSort
StoreSort
Fired before sorting
beforeUpdate
AjaxStore
Fired before record is modified in this store. Modification may be vetoed by returning false from a handler.
beginDataUpdate
internal
AjaxStore
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
commitAdded
AjaxStore
Fired after committing added records
commitModified
AjaxStore
Fired after committing modified records
commitRemoved
AjaxStore
Fired after committing removed records
destroy
Events
Fires when an object is destroyed.
endDataUpdate
internal
AjaxStore
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.
exception
AjaxStore
Fired when a remote request fails, either at the network level, or the server returns a failure, or an invalid response.
Note that when a commit fails, more than one exception event will be triggered. The individual operation, create, update or delete will trigger their own exception event, but the encapsulating commit operation will also trigger an exception event when all the operations have finished, so if exceptions are going to be handled gracefully, the event's action property must be examined, and the constituent operations of the event must be examined.
filter
StoreFilter
Fired after applying filters to the store
formulaError
internal
AjaxStore
Fired when a formula defined on a datafield fails to evaluate.
group
StoreGroup
Fired when grouping changes
idChange
AjaxStore
Fired when the id of a record has changed
indent
StoreTree
Fired after tasks in the tree are indented
load
AjaxStore
Fired on successful load
loadChildren
AjaxStore
Fired on successful load of remote child nodes for a tree node.
loadChildrenStart
AjaxStore
Fired when loading of remote child nodes into a tree node is beginning. This is not cancelable. Parameters in the event may still be mutated at this stage.
loadPage
StorePaging
When the store is paged, this is fired when a page is loaded.
loadPageStart
AjaxStore
When the store is paged, this is fired when a page load is beginning.
loadStart
AjaxStore
Fired when loading is beginning. This is not cancelable. Parameters in the event may still be mutated at this stage.
move
AjaxStore
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
AjaxStore
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
AjaxStore
Fired when the root node is set
sort
StoreSort
Fired after sorting
update
AjaxStore
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
AjaxStore
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
AjaxStore
Called after any remote request has finished whether successfully or unsuccessfully.
onBatchedUpdate
private
AjaxStore
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.
onBeforeLoad
PREVENTABLE
AjaxStore
Called before loading starts. Allows altering parameters and is cancelable by returning false. For paged stores, instead listen to beforeLoadPage. For remote loading of tree child nodes, listen to beforeLoadChildren.
onBeforeLoadChildren
PREVENTABLE
AjaxStore
Called before loading of remote child nodes of a tree node starts. Allows altering parameters and is cancelable
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
AjaxStore
Called before any remote request is initiated.
onBeforeSort
StoreSort
Called before sorting
onBeforeUpdate
AjaxStore
Called before record is modified in this store. Modification may be vetoed by returning false from a handler.
onBeginDataUpdate
internal
AjaxStore
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
onCommitAdded
AjaxStore
Called after committing added records
onCommitModified
AjaxStore
Called after committing modified records
onCommitRemoved
AjaxStore
Called after committing removed records
onDestroy
Events
Called when an object is destroyed.
onEndDataUpdate
internal
AjaxStore
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.
onException
AjaxStore
Called when a remote request fails, either at the network level, or the server returns a failure, or an invalid response.
Note that when a commit fails, more than one exception event will be called. The individual operation, create, update or delete will trigger their own exception event, but the encapsulating commit operation will also trigger an exception event when all the operations have finished, so if exceptions are going to be handled gracefully, the event's action property must be examined, and the constituent operations of the event must be examined.
onFilter
StoreFilter
Called after applying filters to the store
onFormulaError
internal
AjaxStore
Called when a formula defined on a datafield fails to evaluate.
onGroup
StoreGroup
Called when grouping changes
onIdChange
AjaxStore
Called when the id of a record has changed
onIndent
StoreTree
Called after tasks in the tree are indented
onLoad
AjaxStore
Called on successful load
onLoadChildren
AjaxStore
Called on successful load of remote child nodes for a tree node.
onLoadChildrenStart
AjaxStore
Called when loading of remote child nodes into a tree node is beginning. This is not cancelable. Parameters in the event may still be mutated at this stage.
onLoadPage
StorePaging
When the store is paged, this is called when a page is loaded.
onLoadPageStart
AjaxStore
When the store is paged, this is called when a page load is beginning.
onLoadStart
AjaxStore
Called when loading is beginning. This is not cancelable. Parameters in the event may still be mutated at this stage.
onMove
AjaxStore
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
AjaxStore
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
AjaxStore
Called when the root node is set
onSort
StoreSort
Called after sorting
onUpdate
AjaxStore
Called when a record is modified

Source path

SchedulerPro/data/CalendarManagerStore.js

CalendarManagerStore

See also

Configs

Handlers as function name

Parameters

Returns

Threshold

Missing fields

`changes` behavior

Parameters

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

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 tree4

Mixins17

Contents

CalendarManagerStore

See also

Configs

Handlers as function name

Parameters

Returns

Threshold

Missing fields

changes behavior

Parameters

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

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 tree4

Mixins17

Contents

`changes` behavior

`changes` behavior