TimeRangeModel

This class represents a named time range. It is used by the TimeRanges feature.

This class inherits most of its fields from TimeSpan. The most important of these fields are the following:

It's an indirect subclass of Model. Please refer to documentation of those classes to become familiar with the base interface of this class. The data source of any field can be customized in the subclass. Please refer to Model for details.

Time ranges may recur. See the recurrenceRule field.

const timeRange = new TimeRangeModel({
    name      : 'Lunch break',
    startDate : '2024-01-15T12:00',
    endDate   : '2024-01-15T13:00',
    cls       : 'lunch-break'
});

Fields

Fields belong to a Model class and define the Model data structure

id : String/Number

Model

Unique identifier for the record. Might be mapped to another dataSource using idField, but always exposed as record.id. Will get a generated value if none is specified in records data.

Note that generated ids are meant to be temporary (phantom ids), they should not be serialized but instead replaced by the backend on commit
name : String

TimeSpan

The name of the time span (or Event / Task)
readOnly : Boolean

Model

Flag the record as read-only on the UI level, preventing the end user from manipulating it using editing features such as cell editing and event dragging.

Does not prevent altering the record programmatically, it can still be manipulated by application code.

For more info, see the "Read-only records" section above.
timeZone : String/Number/null

TimeZonedDatesMixin

The current timeZone this record is converted to. Used internally to keep track of time zone conversions.

Can also be used to create a new record with dates in a specific non-local timezone. That is useful for example when replacing a store dataset. That would be interpreted as a new load, and all dates would be converted to the configured timezone.

If specifically set to null when adding a new record to a Store, the new record's dates will be converted to the Project's configured timezone.

If set to false on a record, that record will be excluded from timezone conversion.

For more information about timezone conversion, se timeZone.

This field will not persist by default.
duration : Number

TimeSpan

The numeric part of the timespan's duration (the number of units).
durationUnit : DurationUnit

TimeSpan
The unit part of the TimeSpan duration, defaults to "d" (days). Valid values are:
- "millisecond" - Milliseconds
- "second" - Seconds
- "minute" - Minutes
- "hour" - Hours
- "day" - Days
- "week" - Weeks
- "month" - Months
- "quarter" - Quarters
- "year"- Years
This field is readonly after creation, to change durationUnit use #setDuration().
endDate : String/Date

TimeSpan

The end date of a time span (or Event / Task).

Uses DateHelper.defaultFormat to convert a supplied string to a Date. To specify another format, either change that setting or subclass TimeSpan and change the dateFormat for this field.

Note that the field always returns a Date.

exceptionDates : String/String[]

RecurringTimeSpan

A string (either a single date or multiple dates separated by comma) or an array of strings containing the timespan exception dates. The dates that must be skipped when generating occurrences for a repeating timespan. This is used to modify only individual occurrences of the timespan so the further regenerations won't create another copy of this occurrence again.

{
    id: 7,
    startDate: '2021-10-12T14:00:00',
    endDate: '2021-10-12T15:00:00',
    name: 'Lunch',
    resourceId: 'hotel',
    recurrenceRule: 'FREQ=DAILY;COUNT=5',
    exceptionDates: ['2021-10-14']
}

Use addExceptionDate method to add an individual entry to the dates array:

// Break the link between the occurrence and its base.
// This also adds the occurrence date as an exception date
// so that the base timespan knows that this date should be skipped when regenerating its occurrences.
occurrence.recurringTimeSpan = null;

// now the occurrence is an individual record that can be changed & persisted freely
occurrence.setStartEndDate(new Date(2018, 6, 2), new Date(2018, 6, 3));

Note: The dates in this field get automatically removed when the event changes its start date.

fullDuration : DurationConfig/Duration

TimeSpan

Calculated field which encapsulates the duration's magnitude and unit. This field will not be persisted, setting it will update the duration and durationUnit fields.
recurrenceRule : String

RecurringTimeSpan

The timespan recurrence rule. A string in RFC-5545 described format ("RRULE" expression).
startDate : String/Date

TimeSpan

The start date of a time span (or Event / Task).

Uses DateHelper.defaultFormat to convert a supplied string to a Date. To specify another format, either change that setting or subclass TimeSpan and change the dateFormat for this field.

Note that the field always returns a Date.
cls : DomClassList/String/String[]/Object

TimeSpan

An encapsulation of the CSS classes to add to the rendered time span element.

Always returns a DomClassList, but may still be treated as a string. For granular control of adding and removing individual classes, it is recommended to use the DomClassList API.
iconCls : String

TimeSpan

CSS class specifying an icon to apply to the rendered time span element. Note: In case event is a milestone, using iconCls with dependency feature might slightly decrease performance because feature will refer to the DOM to get exact size of the element.
style : String

TimeSpan
A CSS style string (applied to style.cssText) or object (applied to style)
```
record.style = 'color: red;font-weight: 800';
```
expanded : Boolean

READONLY
Model

Start expanded or not (only valid for tree data)
isFullyLoaded : Boolean

Model
This field is added to the class at runtime when the Store is configured with lazyLoad. If set on a parent record at load time, that parent will not cause any more child load requests. If omitted, it will be automatically set to true when a load request receives fewer child records than requested.

To specifically set this field for a parent at its children load request, provide it as a property in the data response object:
```
return {
   data : [ ... ],
   isFullyLoaded : true
   total : 123
}
```
Or to include grandchildren for a parent, it can be provided as a property on the record data object:
```
return {
   data : [{
      id : 1,
      name : 'My Parent',
      isFullyLoaded : true,
      expanded : true,
      children : [{
         id : 2,
         name : 'My Child'
     }]
   }],
   total : 123
}
```
orderedParentIndex : Number

READONLY
Model

This is a read-only field provided in server synchronization packets to specify which position the node takes in the parent's ordered children array. This index is set on load and gets updated on reordering nodes in tree. Sorting and filtering have no effect on it.
remoteChildCount : Number

DEPRECATED
Model

Deprecated:
This field has been deprecated. Please read the guide to find out if your app needs to use the new isFullyLoaded field.

This field is added to the class at runtime when the Store is configured with lazyLoad. The number specified should reflect the total amount of children of a parent node, including nested descendants.

Properties

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

isModelLink : Booleantrue

READONLY

static

ADVANCED
ModelLink

Identifies an object as an instance of ModelLink class, or subclass thereof.
isModelStm : Booleantrue

READONLY

static

ADVANCED
ModelStm

Identifies an object as an instance of ModelStm class, or subclass thereof.
isRecurringTimeSpan : Booleantrue

READONLY

static

ADVANCED
RecurringTimeSpan

Identifies an object as an instance of RecurringTimeSpan class, or subclass thereof.
isTimeRangeModel : Booleantrue

READONLY

static

ADVANCED

Identifies an object as an instance of TimeRangeModel class, or subclass thereof.
isTimeZonedDatesMixin : Booleantrue

READONLY

static

ADVANCED
TimeZonedDatesMixin

Identifies an object as an instance of TimeZonedDatesMixin class, or subclass thereof.
isTreeNode : Booleantrue

READONLY

static

ADVANCED
Model

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

internal

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

A class property getter for the default values of internal properties for this class.
allFields : DataField[]

READONLY

static
Model

An array containing all the defined fields for this Model class. This will include all superclass's defined fields.
autoExposeFields : Boolean

static
Model

Flag checked from Store when loading data that determines if fields found in first records should be exposed in same way as predefined fields.

Note that we for all but the most basic use cases recommend explicitly defining the fields. Having them auto exposed can lead to unexpected behavior, if the first record is not complete (fields missing, null etc).

childrenField : String

static

Model

The name of the data field which holds children of this Model when used in a tree structure

MyModel.childrenField = 'kids';
const parent = new MyModel({
    name : 'Dad',
    kids : [
        { name : 'Daughter' },
        { name : 'Son' }
    ]
});

defaults : Object

static
Model
Template static getter which is supposed to be overridden to define default field values for the Model class. Overrides defaultValue config specified by the fields getter. Returns a named object where key is a field name and value is a default value for the field.

NOTE: This is a legacy way of defining default values, we recommend using fields moving forward.
```
class Person extends Model {
    static get fields() {
        return [
            { name : 'username', defaultValue : 'New person' }
        ];
    }
}

class Bot extends Person {
    static get defaults() {
        return {
            username : 'Bot' // default value of 'username' field is overridden
        };
    }
}
```
fieldMap : Object<String, DataField>

READONLY

static
Model

An object containing all the defined fields for this Model class. This will include all superclass's defined fields through its prototype chain. So be aware that Object.keys and Object.entries will only access this class's defined fields.

fields : (String|DataFieldConfig|DataField)[]

READONLY

static

Model

Array of defined fields for this model class. Subclasses add new fields by implementing this static getter:

// Model defining two fields
class Person extends Model {
    static get fields() {
        return [
            { name : 'username', defaultValue : 'New person' },
            { name : 'birthdate', type : 'date' }
        ];
    }
}

// Subclass overriding one of the fields
class Bot extends Person {
    static get fields() {
        return [
            // Default value of 'username' field is overridden, any other setting from the parents
            // definition is preserved
            { name : 'username', defaultValue : 'Bot' }
        ];
    }
}

Fields in a subclass are merged with those from the parent class, making it easy to override mappings, formats etc.

Note that later accessing Bot.fields will refer to the block with the redefinition of the username field seen above, not to all fields available (username, birthdate). To access all fields, use either allFields on the Model class, or the fields property on a record.

idField : String

static
Model

The data source for the id field which provides the ID of instances of this Model.
$meta : Object

internal

READONLY

static
Model
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
$name : String

static

ADVANCED
Model
Class name getter. Used when original ES6 class name is minified or mangled during production build. Should be overridden in each class which extends Model or it descendants.
```
class MyNewClass extends Model {
    static $name = 'MyNewClass';
}
```

relations : Object<String, RelationConfig>

static

Model

Override in a subclass of Model to define relations to records in other stores.

Always defined on the "one" side, not the "many" side.

Expects an object where keys are relation names and values are relation configs.

This snippet will define a relation called team, allowing access to the foreign record via player.team. It will point to a record in the teamStore (must be available as record.firstStore.teamStore) with an id matching the players teamId field. The team record in turn, will have a field called players which is a collection of all players in the team.

class Player extends Model {
    static relations = {
        // Define a relation between a player and a team
        team : {
            foreignKey            : 'teamId',
            foreignStore          : 'teamStore',
            relatedCollectionName : 'players'
        }
    }
}

const teamStore = new Store({
    data : [
        { id : 1, name : 'Brynas' },
        { id : 2, name : 'Leksand' }
    ]
});

const playerStore = new Store({
    modelClass : Player,
    // Matches foreignStore, allowing records of playerStore to find the related store
    teamStore,
    data       : [
        // teamId is specified as foreignKey, will be used to match the team
        { id : 1, name : 'Nicklas Backstrom', teamId : 1  },
        { id : 2, name : 'Elias Lindholm',   teamId : 1  },
        { id : 3, name : 'Filip Forsberg',  teamId : 2  }
    ],
}

playerStore.first.team.name // > Brynas
playerStore.last.team.name // > Leksand
teamStore.first.players // > [nick, elias]
teamStore.last.players // > [filip]

To access the related record from the many side, use dot notation for the field name. For example in a Grid column:

const grid = new Grid({
   store : playerStore,
   columns : [
       { field : 'name', text : 'Name' },
       { field : 'team.name', text : 'Team' }
   ]
});

convertEmptyParentToLeaf : Boolean/Objectfalse

static
Model
This static configuration option allows you to control whether an empty parent task should be converted into a leaf. Enable/disable it for a whole class:
```
Model.convertEmptyParentToLeaf = false;
```
By specifying true, all empty parents will be considered leafs. Can also be assigned a configuration object with the following Boolean properties to customize the behaviour:
```
Model.convertEmptyParentToLeaf = {
    onLoad   : false,
    onRemove : true
}
```
- onLoad : Boolean
  
  Apply the transformation on load to any parents without children (children : [])
- onRemove : Boolean
  
  Apply the transformation when all children have been removed from a parent

emptyArray : Array

internal

READONLY
Model

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

internal

READONLY
Model

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

READONLY

ADVANCED
Model

Identifies an object as an instance of Model class, or subclass thereof.
isTimeRangeModel : Booleantrue

READONLY

ADVANCED

Identifies an object as an instance of TimeRangeModel class, or subclass thereof.
isTimeSpan : Booleantrue

READONLY

ADVANCED
TimeSpan

Identifies an object as an instance of TimeSpan class, or subclass thereof.
copyOf : Model

READONLY
Model

For copied records, this property links to the original model instance from which it was copied.
isBatchUpdating : Boolean

READONLY
Model

True if this Model is currently batching its changes.
isCommitting : Boolean

READONLY
Model

True if this models changes are currently being committed.
isCreating : Boolean
Model

Set this property to true when adding a record on a conditional basis, that is, it is yet to be confirmed as an addition.

When this is set, the isPersistable value of the record is false, and upon being added to a Store it will not be eligible to be synced with the server as an added record.

Subsequently, clearing this property means this record will become persistable and eligible for syncing as an added record.
isModified : Boolean

READONLY
Model

True if this model has any uncommitted changes.
isValid : Boolean

READONLY
Model

Check if record has valid data. Default implementation returns true, override in your model to do actual validation.
modificationData : Object

READONLY
Model

Get a map of the modified fields in form of an object. The field´s dataSource is used as the property name in the returned object. The record's id is included unless its persist config is false.
modificationDataToWrite : Object

READONLY
Model

Get a map of the modified data fields along with any alwaysWrite fields, in form of an object. The field´s dataSource is used as the property name in the returned object. Used internally by AjaxStore / CrudManager when sending updates.
modifications : Object

READONLY
Model

Get a map of the modified fields in form of an object. The field names are used as the property names in the returned object, and the property values are the latest field values.

The id field is included unless its persist config is false.
persistableData : Object

internal

READONLY
Model

Returns data for allpersistable fields in form of an object, using dataSource if present.
rawModificationData : Object

internal

READONLY
Model

Returns a map of the modified persistable fields
classDisplayName : String

READONLY
Model

Returns the string value for display purposes of an instance of this Model class. Needs to be overridden in subclasses.
fieldNames : String[]

READONLY
Model

Get the names of all properties in the data object.

Note that this is not the same as the fields defined for the model, in most cases you probably want to use fields instead.
groupChildren : Model[]/undefined

READONLY
Model

When called on a group header row returns list of records in that group. Returns undefined otherwise.
isGroupHeader : Boolean

READONLY
Model

Returns true for a group header record
generatedParent : Boolean

READONLY
Model

Reports true when the record is a parent record generated by the TreeGroup feature.

Only valid for stores used with TreeGroup feature enabled.
hasGeneratedId : Boolean

READONLY
Model

Checks if record has a generated id.

New records are assigned a generated id based on a UUID (starting with _generated), which is intended to be temporary and should be replaced by the backend on commit.
internalId : Number

READONLY
Model

Gets the records internalId. It is assigned during creation, guaranteed to be globally unique among models.
isPhantom : Boolean

READONLY
Model

Returns true if the record is new and has not been persisted (and received a proper id).
key : *

READONLY
Model

Holds the value that a generated group parent represents when using the TreeGroup feature.

Only valid for stores used with TreeGroup feature.

json : String

Model

Get the records data as a json string.

const record = new Model({
    title    : 'Hello',
    children : [
        ...
    ]
});

const jsonString = record.json;

//jsonString:
'{"title":"Hello","children":[...]}'

config : Object

READONLY

ADVANCED
Model

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

READONLY

ADVANCED
Model

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

READONLY
Model

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
Model

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).
hasLinks : Boolean

READONLY
ModelLink

Are other records linked to this record?
isLinked : Boolean

READONLY
ModelLink

Is this record linked to another record?
originalRecord : Model[]

READONLY
ModelLink

Get the original record this record is linked to.
recordLinks : Model[]

READONLY
ModelLink

Get links to this record.
eventStore : EventStore

READONLY
TimeSpan

Returns the event store this event is part of, if any.
firstStore : Store

READONLY
Model

Get the first store that this model is assigned to.
stm : StateTrackingManager
ModelStm

Reference to STM manager, if used
isPersistable : Boolean

READONLY
Model

This yields true if this record is eligible for syncing with the server. It can yield false if the record is in the middle of a batched update, or if it is a tentative record yet to be confirmed as a new addition.
isRemoved : Boolean

internal

READONLY
Model

Returns true if this record is not part of any store.
allChildren : Model[]

READONLY
Model

Retrieve all children, excluding filtered out nodes (by traversing sub nodes)
allUnfilteredChildren : Model[]

READONLY
Model

Retrieve all children, including filtered out nodes (by traversing sub nodes)
childLevel : Number

READONLY
Model

Depth in the tree at which this node exists. First visual level of nodes are at level 0, their direct children at level 1 and so on.
descendantCount : Number
Model

Count all children (including sub-children) for a node (in its `firstStore´)
firstChild : Model

READONLY
Model

Get the first child of this node
indexPath : Number[]

private

READONLY
Model

Returns index path to this node. This is the index of each node in the node path starting from the topmost parent. (only relevant when its part of a tree store).
isLeaf : Boolean

READONLY
Model

Is a leaf node in a tree structure?
isLoaded : Boolean

READONLY
Model

Returns true for parent nodes with children loaded (there might still be no children)
isParent : Boolean

READONLY
Model

Is a parent node in a tree structure?
isRoot : Boolean

READONLY
Model

Returns true if this node is the root of the tree
lastChild : Model

READONLY
Model

Get the last child of this node
nextSibling : Model

READONLY
Model

Get the next sibling of this node
orderedChildren : Model[]/null

READONLY
Model

The direct children of this node in their original structural order, unaffected by sorting and filtering. Returns null for leaf nodes.

Unlike children, which reflects the current sort order and active filters, this property always returns all children in the order they were originally inserted.
parent : Model

READONLY
Model

This is a read-only property providing access to the parent node.
parentId : Number/String/null
Model

Reading this property returns the id of the parent node, if this record is a child of a node.

Setting this property appends this record to the record with the passed id in the same store that this record is already in.

Note that setting this property is only valid if this record is already part of a tree store.

This is not intended for general use. This is for when a server responds to a record mutation and the server decides to move a record to a new parent. If a parentId property is passed in the response data for a record, that record will be moved.
previousSibling : Model

READONLY
Model

Get the previous sibling of this node
previousSiblingsTotalCount : Number

READONLY
Model

Returns count of all preceding sibling nodes (including their children).
unfilteredChildren : Model[]/null

private
Model

Array of tree nodes without any filter applied. On first filter, will take order from sorted children, but is not thereafter kept in sorted order, so order should not be relied upon.
visibleDescendantCount : Number
Model

Count visible (expanded) children (including sub-children) for a node (in its firstStore)
wbsCode : String
TimeSpan

Returns the WBS code of this model (e.g '2.1.3'). Only relevant when part of a tree store, as in the Gantt chart.
isOccurrence : Boolean

READONLY
RecurringTimeSpan

Indicates if the timespan is an occurrence of another recurring timespan.
isRecurring : Boolean

READONLY
RecurringTimeSpan

Indicates if the timespan is recurring.
newExceptionDate : Date

private

READONLY
RecurringTimeSpan

The setter used by Model#inSet when addExceptionDate is called. Adding an exception must trigger change processing in a recurring event, so it must be changed through a set call. Also, the change must be batchable with other changes.
occurrenceDate : Date

internal

READONLY
RecurringTimeSpan

The original {@lScheduler.model.TimeSpan#field-startDate startDate} of this event before any modifications took place. Used by removeOccurrence and detachFromRecurringEvent
occurrenceIndex : Number

READONLY
RecurringTimeSpan

If this event is an occurrence of a recurring event, then this property yields its zero-based occurrence index in the sequence.
occurrenceMap : Map

internal

READONLY
RecurringTimeSpan

A Map, keyed by each date an occurrence intersects, of occurrences of this event.
occurrences : TimeSpan[]

internal

READONLY
RecurringTimeSpan

Array of this recurring timespan's cached occurrences. Not including the owning recurring event.

Empty if the timespan is not recurring.

Note that this is an internal accessor and is cleared whenever changes are made to the owning recurring event.
recurrence : RecurrenceModel
RecurringTimeSpan

The recurrence model used for the timespan.
recurrenceModel : String
RecurringTimeSpan

Name of the class representing the recurrence model, defaults to RecurrenceModel
recurringTimeSpan : TimeSpan

internal

READONLY
RecurringTimeSpan

The "main" timespan this model is an occurrence of. For non-occurrences returns null.
supportsRecurring : Boolean

READONLY
RecurringTimeSpan

Returns true if this timespan supports recurring.
dates : Date[]

READONLY
TimeSpan

Returns an array of dates in this range. If the range starts/ends not at the beginning of day, the whole day will be included.
durationMS : Number

READONLY
TimeSpan

Returns the duration of this Event in milliseconds.
isMilestone : Boolean

READONLY
TimeSpan

Returns true if record is a milestone.
isScheduled : Boolean

READONLY
TimeSpan

Checks if the range record has both start and end dates set and start <= end
rawDurationMS : Number

READONLY
TimeSpan

Returns the event raw duration in milliseconds. Calculated as a simple distance between the event start and end dates in milliseconds. And thus this value (in Scheduler Pro and Gantt) doesn't take into account non-working time nor the project conversion rates.
hierarchyModificationDataToWrite : Object

internal

READONLY
Model

Returns values of the persistable tree-defining fields: parentId, orderedParentIndex, and parentIndex or sparseIndex. parentIndex is omitted when sparseIndex is used.

Functions

Functions are methods available for calling on the class

hasConfigPath( object, path )
: Boolean

internal

static
Model

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

internal

static
Model

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

private

static
Model

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

internal

static
Model

This optional class method is called when a class is mixed in using the mixin() method.
getDefaultConfiguration( )
: Object

internal

static
Model

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
Model

This method is called as part of setupClass(). It will process the configurable() return object and the defaultConfig return object.
addField( fieldDef )
: DataField

static
Model

Add a field definition in addition to those predefined in fields.
applyDefaults( defaults )

static

ADVANCED
Model
Overrides applyDefaults to also handle Model field defaults.

When a key in the provided object matches a defined field name, the field's default value is updated so that new instances will use the new default. Non-field keys are passed through to the superclass implementation to handle config defaults.
```
EventModel.applyDefaults({ durationUnit : 'week' });
```
exposeProperties( data, rawtrue )

internal

static
Model

Makes getters and setters for fields (from definitions and data). Called once when class is defined and once when data is loaded first time.
isTimeZoneDateField( fieldName )
: Boolean

static
TimeZonedDatesMixin

Returns true if the field is adjusted by timeZone config.
processData( data, updatingfalse )
: Object

private

static
Model

Processes raw data, converting values and setting defaults.
processField( fieldName, value )
: *

static
Model

Processes input to a field, converting to expected type.
removeField( fieldName )

static
Model

Remove a field definition by name.
asId( model )
: String/Number

static
Model

Gets the id of specified model or model data object, or the value if passed string/number.
generateId( text )
: String/Number

static
Model
Generates an id for a new record (a phantom id), based on a UUID by default.

This function can be overridden to provide custom id generation logic.
```
let idCounter = 0;
// Override the default logic with app specific
Model.generateId = () => `id${new Date().getTime()}${idCounter++}`;
```
destroy( ...args )

static

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

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

static

ADVANCED
Model

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

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.
fieldSorter( a, b )
: Number

private

static
Model

This function forces correct field order. Correct order is parentId before id. If we process id field before parentId, idMap won't be updated and changing parent node will lead to duplicated records in storage
getFieldDataSource( fieldName )
: String

internal

static
Model

Returns dataSource configuration for a given field name
exposeRelations( )

internal

static
Model

Makes getters and setters for related records. Populates a Model#relation array with the relations, to allow it to be modified later when assigning stores.

constructor( config, store, meta )
Model

Constructs a new record from the supplied data config.
_thisIsAUsedExpression( expression )

internal
Model

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
Model

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
Model

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
Model

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

internal
Model

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
Model

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

internal
Model

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
Model

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

private
Model

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
Model

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.
classHierarchy( topClass )
: Function[]

private
Model

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

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

internal
Model

This method is called when any config changes.
beginBatch( )
Model
Begin a batch, which stores changes and commits them when the batch ends. Prevents events from being fired during batch.
```
record.beginBatch();
record.name = 'Mr Smith';
record.team = 'Golden Knights';
record.endBatch();
```
Please note that you can also set multiple fields in a single call using set, which in many cases can replace using a batch:
```
record.set({
  name : 'Mr Smith',
  team : 'Golden Knights'
});
```
cancelBatch( )
Model

Cancels current batch operation. Any changes during the batch are discarded.
clearChanges( includeDescendantstrue )
Model

Clears tracked changes, used on commit. Does not revert changes.
copy( newIdOrData, deep )
: Model

Model
Makes a copy of this model, assigning the specified id or a generated id and also allowing you to pass field values to the created copy. A copyOf property is set on the copy to reference the original record.
```
const record = new Model({ name : 'Super model', hairColor : 'Brown' });
const clone = record.copy({ name : 'Super model clone' });
```
endBatch( silentfalse )
Model

End a batch, triggering events if data has changed.
getData( fieldName )
: *

Model

Returns raw data from the encapsulated data object for the passed field name
getUnmodified( fieldName )
: *

Model

Returns the unmodified value of the field, as in the value it had after the last commit. If the field has not been modified, the current value is returned.
hasBatchedChange( fieldName )
: Boolean

Model

Returns true if this Model currently has outstanding batched changes for the specified field name.
isFieldModified( fieldName )
: Boolean

Model

Returns true if this model has uncommitted changes for the provided field.
revertChanges( )
Model

Reverts changes in this back to their original values.
set( field, value, silentfalse )
Model
Set value for the specified field. You can also use the generated setters if loading through a Store.

Setting a single field, supplying name and value:
```
record.set('name', 'Clark');
```
Setting multiple fields, supplying an object:
```
record.set({
    name : 'Clark',
    city : 'Metropolis'
});
```
NOTE: Do not modify fields using dataSource, as it is intended only for reading and writing from the raw data object. Fields should be modified using name as it is the public interface.

Triggers: idChange, update, change

setData( )

internal

Model

Internal function used to update a records underlying data block (record.data) while still respecting field mappings. Needed in cases where a field needs setting without triggering any associated behaviour and it has a dataSource with a different name.

For example:

// startDate mapped to data.beginDate
{ name : 'startDate', dataSource : 'beginDate' }

// Some parts of our code needs to update the data block without triggering any of the behaviour associated with
// calling set. This would then not update "beginDate":
record.data.startDate = xx;

// But this would
record.setData('startDate', xx);

detachListeners( name )

ADVANCED
Model

Removes all event listeners that were registered with the passed names.
get( fieldName )
: *

Model

Get value for specified field name. You can also use the generated getters if loading through a Store. If model is currently in batch operation this will return updated batch values which are not applied to Model until endBatch() is called.
getDataSource( fieldName )
: String

Model

Get the data source used by specified field. Returns the fieldName if no data source specified.
getFieldDefinition( fieldName )
: DataField

Model

Convenience function to get the definition for a field from class.
getFieldPersistentValue( nameOrField )

private
Model

Returns field value that should be persisted, or undefined if field is configured with persist: false.

toJSON( )

: Object

Model

Used by JSON.stringify() to correctly convert this record to json.

In most cases no point in calling it directly.

// This will call `toJSON()`
const json = JSON.stringify(record);

If called manually, the resulting object is a clone of record.data + the data of any children:

const record = new Model({
    title    : 'Hello',
    children : [
        ...
    ]
});

const jsonObject = record.toJSON();

// jsonObject:
{
    title : 'Hello',
    children : [
        ...
    ]
}

toString( )
: String

Model
Represent the record as a string, by default as a JSON string. Tries to use an abbreviated version of the object's data, using id + name/title/text/label/description. If no such field exists, the full data is used.
```
const record = new Model({ id : 1, name : 'Steve Rogers', alias : 'Captain America' });
console.log(record.toString()); // logs { "id" : 1, "name" : "Steve Rogers" }
```
afterConfigure( )

internal
Model

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
Model

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
Model

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

ADVANCED
Model

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
Model
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');
```
doDestroy( )

ADVANCED
Model
Classes implement this method to provide custom cleanup logic before calling super.doDestroy(). The general pattern is as follows:
```
 class Foo extends Base {
     doDestroy() {
         // perform custom cleanup

         super.doDestroy();
     }
 }
```
This method is called by destroy which also prevents multiple calls from reaching doDestroy. Prior to calling doDestroy, isDestroying is set to true. Upon return, the object is fully destructed and isDestroyed is set to true.

Do not call this method directly. Instead call destroy.
finishConfigure( )

internal
Model

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
Model

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
Model

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' )
Model

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

ADVANCED
Model

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( )
Model

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.
equals( other )
: Boolean

Model

Compares this Model instance to the passed instance. If they are of the same type, and all fields (except, obviously, id) are equal, this returns true.
exportToICS( icsEventConfig )
TimeSpan
Triggers a download of this time span in ICS format (for import in Outlook etc.)
```
timeSpan.downloadAsICS({
     LOCATION : timeSpan.location
 });
```
instanceMeta( instanceOrId )

private
Model

Used to set per external instance meta data. For example useful when using a record in multiple grids to store some state per grid.
isPartOfStore( store )
: Boolean

internal
Model

Returns true if this record is contained in the specified store, or in any store if store param is omitted.
joinStore( store )

internal
Model

Joins this record and any children to specified store, if not already joined.
link( )
: Proxy

ModelLink

Creates a proxy record (using native Proxy) linked to this record (the original). The proxy records shares most data with the original, except for its id (which is always generated), and ordering fields such as parentIndex and parentId etc.

Any change to the proxy record will be reflected on the original, and vice versa. A proxy record is not meant to be persisted, only the original record should be persisted. Thus, proxy records are not added to stores change tracking (added, modified and removed records).

Removing the original record removes all proxies.

Creating a proxy record allows a Store to seemingly contain the record multiple times, something that is otherwise not possible. It also allows a record to be used in both a tree store and in a flat store.

Not all UI features support linked records
resolveCallback( handler, thisObj, enforceCallabilitytrue )
: Object

ADVANCED
Model

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.
unjoinStore( store, isReplacingfalse )

internal
Model

Unjoins this record and any children from specified store, if already joined.
isEditable( fieldName )
: Boolean/undefined

Model

Defines if the given event field should be manually editable in UI. You can override this method to provide your own logic.
refreshCalculatedField( field )
: *

internal
Model

Recalculates the value of a calculated field
syncId( value )

private
Model

Silently updates record's id with no flagging the property as modified. Triggers onModelChange event for changed id.
triggerBeforeUpdate( changes )
: Boolean

private
Model

Triggers beforeUpdate event for each store and checks if changes can be made from event return value.
getStoreLinks( store, limit0 )
: Model[]

private
ModelLink

Returns all links of the record in the provided store.
afterInsertChild( )

private
ModelStm

Called from insertChild to notify StateTrackingManager about children insertion. Provides it with all necessary context information collected in beforeInsertChild required to undo/redo the action.
afterRemoveChild( )

private
ModelStm

Called from removeChild to notify StateTrackingManager about children removing. Provides it with all necessary context information collected in beforeRemoveChild required to undo/redo the action.
afterSet( )

private
ModelStm

Overridden to store initial data of the changed fields and to notify STM manager about the change action if anything has been changed in result.

The method is called from within set method.
beforeInsertChild( childRecords )
: Array

private
ModelStm

Called from insertChild to obtain inserted records initial parents and parent index, to be able to restore the state back upon undo.
beforeRemoveChild( childRecords, isMove )
: Array

private
ModelStm

Called from removeChild to obtain removed records initial parent index, to be able to restore the state back upon undo.
ancestorsExpanded( store )
: Boolean

Model

This method returns true if this record has all expanded ancestors and is therefore eligible for inclusion in a UI.
appendChild( childRecord, silentfalse )
: Model/Model[]/null

Model

Append a child record(s) to any current children.
bubble( fn, skipSelffalse )
Model

Bubbles up from this node, calling the specified function with each node.
bubbleWhile( fn, skipSelffalse )
: Boolean

Model

Bubbles up from this node, calling the specified function with each node, while the function returns true.
clearChildren( silentfalse )
: Model[]

Model

Removes all child nodes from this node.
contains( childOrId, skipSelffalse, options )
: Boolean

Model

Checks if this model contains another model as one of it's descendants
convertToParent( silentfalse )
Model

Converts a leaf node to a parent node, assigning an empty array as its children
getDescendantCount( onlyVisiblefalse, store )
: Number

Model

Count visible (expanded)/all children for this node, optionally specifying for which store.
insertChild( childRecord, before, silentfalse )
: Model/Model[]/null

Model

Insert a child record(s) before an existing child record.
isExpanded( store )
: Boolean

Model

Used by stores to assess the record's collapsed/expanded state in that store.
processChildren( )

internal
Model

Called during creation to also turn any children into Models joined to the same stores as this model
removeChild( childRecords, isMovefalse, silentfalse )
: Model[]

Model

Remove a child record. Only direct children of this node can be removed, others are ignored.
replaceChildren( childRecords )
: Model[]

Model

Replaces all child nodes with the new node set.
traverse( fn, skipSelffalse, options )
Model

Traverses all child nodes recursively calling the passed function on a target node before iterating the child nodes.
traverseBefore( fn, skipSelffalse, options )
Model

Traverses all child nodes recursively calling the passed function on child nodes of a target before calling it on the node.
traverseWhile( fn, skipSelffalse, options )
: Boolean

Model

Traverses child nodes recursively while fn returns true
addExceptionDate( date )
RecurringTimeSpan

Adds an exception date that should be skipped when generating occurrences for the timespan. The method adds an entry to the array kept in exceptionDates field.
buildOccurrence( occurrenceDate, isFirst )
: TimeSpan

internal
RecurringTimeSpan

Builds an occurrence of this recurring event by cloning the timespan data. The method is used internally by the RecurringTimeSpans mixin. Override it if you need to customize the generated occurrences.

If the date requested is the start date of the event sequence, this record is returned. All runs of recurring events begin with the base record.
detachFromRecurringEvent( )

internal
RecurringTimeSpan

Detaches an occurrence from its owning recurring event so that it can be added to the eventStore either as an exception, or as the start of a new recurring sequence.
getOccurrencesForDateRange( startDate, endDate )
: TimeSpan[]

RecurringTimeSpan

Returns the occurrences of this event over the specified time range. If the first occurrence is in the time range *this* record is included in that position.
hasException( date )
: Boolean

RecurringTimeSpan

Does this recurring event have an exception on the passed date.
hasOccurrencesInDateRange( startDate, endDate )
: Boolean

RecurringTimeSpan

Returns true if this recurring timespan has any occurrences within the specified date range. More efficient than getOccurrencesForDateRange when you only need to check existence, since it short-circuits on the first match without materializing all occurrences.
onRecurrenceChanged( )

internal
RecurringTimeSpan

The method is triggered when the timespan recurrence settings get changed. It updates the recurrenceRule field in this case.
remove( )
RecurringTimeSpan

Override of Model's method. If an isOccurrence is passed, it is detached from its parent recurring event. If it still has a recurrence then the recurring event is changed to stop at the occurrence date. If it has no recurrence an exception is added at the occurrence date.
removeOccurrence( dateOrTimeSpan )

internal
RecurringTimeSpan

Removes an occurrence from this recurring timespan's cached occurrences.
removeOccurrences( )

internal
RecurringTimeSpan

Removes this recurring timespan's cached occurrences.
removeOccurrencesFrom( )

internal
RecurringTimeSpan

Removes all cached occurrences on or after the passed date from this recurring timespan's cached occurrences.
setRecurrence( recurrence, interval, recurrenceEnd )
RecurringTimeSpan

Sets a recurrence for the timespan with a given frequency, interval, and end.
getRelationConfig( name )
: Object

private
Model

Get a relation config by name, from the first store.
initRelation( config )
: Model

private
Model

Initializes/updates a single relation.
initRelations( )

private
Model

Initializes model relations. Called from store when adding a record.
forEachDate( func, thisObj )
TimeSpan

Iterates over the dates
setDuration( duration, durationUnit )
TimeSpan

Sets duration and durationUnit in one go. Only allowed way to change durationUnit, the durationUnit field is readonly after creation
setEndDate( date, keepDurationfalse )
TimeSpan

Sets the range end date
setStartDate( date, keepDurationtrue )
TimeSpan

Sets the range start date
setStartEndDate( start, end, silent )
TimeSpan

Sets the event start and end dates
split( splitPoint0.5 )
: TimeSpan

TimeSpan

Splits this event into two pieces at the desired position.
getDurationInUnit( unit, doNotRound )
: Number

private
TimeSpan

Returns duration of the event in given unit. This is a wrapper for getDurationInUnit
shift( amount, unit )
TimeSpan

Shift the dates for the date range by the passed amount and unit
clear( )

private
Model

Removes all records from the rootNode
sortOrderedChildren( deeptrue, usePreviousOrderfalse )
: Set

private
Model

Iterates orderedChildren array to apply sorting order according to orderedParentIndex. Normally sorting is not required because order is maintained on append/insert. But is useful when pasting number of records to restore their original order.

Source path

Scheduler/model/TimeRangeModel.js

TimeRangeModel

See also

Fields

Properties

Resolving a value from an owner

Value Merging

Config Options

Default Value

Functions

Source path

Inheritance tree4

Mixins5

Contents