DependencyModel

This model represents a dependency between two events, usually added to a DependencyStore.

It is a subclass of the DependencyBaseModel class, which in its turn subclasses Model. Please refer to documentation of those classes to become familiar with the base interface of this class.

Fields and references

A Dependency has a few predefined fields, see Fields below. The name of any fields data source can be customized in the subclass, see the example below. Please also refer to Model for details.

class MyDependency extends DependencyModel {
  static get fields() {
    return [
      { name: 'to', dataSource: 'targetId' },
      { name: 'from', dataSource: 'sourceId' }
    ]);
  }
}

After load and project normalization, these references are accessible (assuming their respective stores are loaded):

fromEvent - The event on the start side of the dependency
toEvent - The event on the end side of the dependency

Async resolving of references

As described above, a dependency has links to events. These references are populated async, using the calculation engine of the project that the resource via its store is a part of. Because of this asyncness, references cannot be used immediately after modifications:

dependency.from = 2;
// dependency.fromEvent is not yet up to date

To make sure references are updated, wait for calculations to finish:

dependency.from = 2;
await dependency.project.commitAsync();
// dependency.fromEvent is up to date

As an alternative, you can also use setAsync() to trigger calculations directly after the change:

await dependency.setAsync({ from : 2});
// dependency.fromEvent is up to date

Fields

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

id : String/Number

DependencyBaseModel

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
readOnly : Boolean

DependencyBaseModel

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.
calendar : CalendarModel/String/Number

The calendar of the dependency used to take lag duration into account.
active : Boolean

Set to false to ignore this dependency in scheduling
bidirectional : Boolean

DependencyBaseModel

Bidirectional, drawn with arrows in both directions
from : String/Number

DependencyBaseModel

From event, id of source event
fromEvent : EventModel/String/Number

DependencyBaseModel

Gets/sets the source event of the dependency.

Accepts multiple formats but always returns an EventModel.

NOTE: This is not a proper field but rather an alias, it will be serialized but cannot be remapped. If you need to remap, consider using from instead.
fromSide : 'top'/'left'/'bottom'/'right'

DependencyBaseModel

Start side on source (top, left, bottom, right)
lag : Number

DependencyBaseModel

The magnitude of this dependency's lag (the number of units).
lagUnit : DurationUnit/DurationUnitShort

READONLY
DependencyBaseModel
The units of this dependency's lag, defaults to "d" (days). Valid values are:
- "ms" (milliseconds)
- "s" (seconds)
- "m" (minutes)
- "h" (hours)
- "d" (days)
- "w" (weeks)
- "M" (months)
- "y" (years)
This field is readonly after creation, to change lagUnit use setLag().
to : String/Number

DependencyBaseModel

To event, id of target event
toEvent : EventModel/String/Number

DependencyBaseModel

Gets/sets the target event of the dependency.

Accepts multiple formats but always returns an EventModel.

NOTE: This is not a proper field but rather an alias, it will be serialized but cannot be remapped. If you need to remap, consider using to instead.
toSide : 'top'/'left'/'bottom'/'right'

DependencyBaseModel

End side on target (top, left, bottom, right)
type : Number

DependencyBaseModel

Dependency type, see static property Type
children : Boolean/Object[]/Model[]

READONLY
TreeNode

Child nodes. To allow loading children on demand, specify children : true in your data. Omit the field for leaf tasks.

Note, if the tree store loads data from a remote origin, make sure readUrl is specified, and optionally parentIdParamName is set, otherwise loadChildren has to be implemented.
cls : String

DependencyBaseModel

CSS class to apply to lines drawn for the dependency
expanded : Boolean

READONLY
DependencyBaseModel

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

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

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.
parentId : String/Number/null

READONLY
TreeNode

This is a read-only field provided in server synchronization packets to specify which record id is the parent of the record.
parentIndex : Number

READONLY
TreeNode

This is a read-only field provided in server synchronization packets to specify which position the node takes in the parent's children array. This index is set on load and gets updated automatically after row reordering, sorting, etc. To save the order, need to persist the field on the server and when data is fetched to be loaded, need to sort by this field.
remoteChildCount : Number

DEPRECATED
TreeNode

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.

Configs

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

taskStore : EventStore/EventStoreConfig
PartOfProject

An EventStore instance or a config object.

Has a corresponding runtime taskStore property.

Properties

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

isDependencyModel : Booleantrue

READONLY

static

ADVANCED

Identifies an object as an instance of DependencyModel class, or subclass thereof.
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.
isPartOfProject : Booleantrue

READONLY

static

ADVANCED
PartOfProject

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

READONLY

static

ADVANCED
TreeNode

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

internal

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

A class property getter for the default values of internal properties for this class.
Type : DependencyType

READONLY

static
DependencyBaseModel
An enumerable object, containing names for the dependency types integer constants.
- 0 StartToStart
- 1 StartToEnd
- 2 EndToStart
- 3 EndToEnd
allFields : DataField[]

READONLY

static
DependencyBaseModel

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

static
DependencyBaseModel

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

DependencyBaseModel

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

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

DependencyBaseModel

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
DependencyBaseModel

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

internal

READONLY

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

DependencyBaseModel

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
TreeNode
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
DependencyBaseModel

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

internal

READONLY
DependencyBaseModel

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

READONLY

ADVANCED
DependencyBaseModel

Identifies an object as an instance of DependencyBaseModel class, or subclass thereof.
isDependencyModel : Booleantrue

READONLY

ADVANCED

Identifies an object as an instance of DependencyModel class, or subclass thereof.
isModel : Booleantrue

READONLY

ADVANCED
DependencyBaseModel

Identifies an object as an instance of Model class, or subclass thereof.
fullLag : Duration
DependencyBaseModel
Property which encapsulates the lag's magnitude and units. An object which contains two properties:
- magnitude : Number
  
  The magnitude of the duration
- unit : DurationUnitShort
  
  The unit in which the duration is measured, e.g., 'd' for days
hardType : Number
DependencyBaseModel

Alias to dependency type, but when set resets fromSide & toSide to null as well.
copyOf : Model

READONLY
DependencyBaseModel

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

READONLY
DependencyBaseModel

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

READONLY
DependencyBaseModel

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

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
DependencyBaseModel

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

READONLY
DependencyBaseModel

Returns true if the linked events have been persisted (e.g. neither of them are 'phantoms')
isValid : Boolean

READONLY
DependencyBaseModel

Returns true if the dependency is valid. It is considered valid if it has a valid type and both from and to events are set and pointing to different events.
modificationData : Object

READONLY
DependencyBaseModel

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
DependencyBaseModel

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
DependencyBaseModel

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
DependencyBaseModel

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

internal

READONLY
DependencyBaseModel

Returns a map of the modified persistable fields
classDisplayName : String

READONLY
DependencyBaseModel

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

READONLY
DependencyBaseModel

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
DependencyBaseModel

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

READONLY
DependencyBaseModel

Returns true for a group header record
generatedParent : Boolean

READONLY
DependencyBaseModel

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
DependencyBaseModel

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
DependencyBaseModel

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

READONLY
DependencyBaseModel

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

READONLY
DependencyBaseModel

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

Only valid for stores used with TreeGroup feature.

json : String

DependencyBaseModel

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
DependencyBaseModel

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

READONLY

ADVANCED
DependencyBaseModel

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

READONLY
DependencyBaseModel

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
DependencyBaseModel

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.
firstStore : Store

READONLY
DependencyBaseModel

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

Reference to STM manager, if used
isRemoved : Boolean

internal

READONLY
DependencyBaseModel

Returns true if this record is not part of any store.
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.
allChildren : Model[]

READONLY
TreeNode

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

READONLY
TreeNode

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

READONLY
TreeNode

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
TreeNode

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

READONLY
TreeNode

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

private

READONLY
DependencyBaseModel

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
TreeNode

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

READONLY
TreeNode

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

READONLY
TreeNode

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

READONLY
TreeNode

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

READONLY
TreeNode

Get the last child of this node
nextSibling : Model

READONLY
TreeNode

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

READONLY
TreeNode

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
TreeNode

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

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
TreeNode

Get the previous sibling of this node
previousSiblingsTotalCount : Number

READONLY
TreeNode

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

private
TreeNode

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
TreeNode

Count visible (expanded) children (including sub-children) for a node (in its firstStore)
project : ProjectModel

READONLY
PartOfProject

Returns the project this entity belongs to.
hierarchyModificationDataToWrite : Object

internal

READONLY
TreeNode

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
DependencyBaseModel

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

internal

static
DependencyBaseModel

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

private

static
DependencyBaseModel

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

internal

static
DependencyBaseModel

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

internal

static
DependencyBaseModel

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
DependencyBaseModel

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

static
DependencyBaseModel

Returns the default dependency type value from the model's field definition.
addField( fieldDef )
: DataField

static
DependencyBaseModel

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

static

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

Makes getters and setters for fields (from definitions and data). Called once when class is defined and once when data is loaded first time.
processData( data, updatingfalse )
: Object

private

static
DependencyBaseModel

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

static
DependencyBaseModel

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

static
DependencyBaseModel

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

static
DependencyBaseModel

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

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

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

static

ADVANCED
DependencyBaseModel

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

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
DependencyBaseModel

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
DependencyBaseModel

Returns dataSource configuration for a given field name
exposeRelations( )

internal

static
DependencyBaseModel

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 )
DependencyBaseModel

Constructs a new record from the supplied data config.
convertLagGen( lag, fromUnit, toUnit )
: Number

Converts lag value from one time unit to another. The method is a generator since it embeds into the Engine scheduling mechanics.
_thisIsAUsedExpression( expression )

internal
DependencyBaseModel

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
DependencyBaseModel

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
DependencyBaseModel

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
DependencyBaseModel

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

internal
DependencyBaseModel

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
DependencyBaseModel

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

internal
DependencyBaseModel

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
DependencyBaseModel

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

private
DependencyBaseModel

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
DependencyBaseModel

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
DependencyBaseModel

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

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

internal
DependencyBaseModel

This method is called when any config changes.
getHardType( )
: Number

DependencyBaseModel

Returns dependency hard type, see hardType.
highlight( cls )
DependencyBaseModel

Applies given CSS class to dependency, the value doesn't persist
isHighlightedWith( cls )
: Boolean

DependencyBaseModel

Checks if the given CSS class is applied to dependency.
setHardType( type )
DependencyBaseModel

Sets dependency type and resets fromSide and toSide to null.
setLag( lag, lagUnit )
DependencyBaseModel

Sets lag and lagUnit in one go. Only allowed way to change lagUnit, the lagUnit field is readonly after creation
unhighlight( cls )
DependencyBaseModel

Removes given CSS class from dependency if applied, the value doesn't persist
beginBatch( )
DependencyBaseModel
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( )
DependencyBaseModel

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

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

DependencyBaseModel
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 )
DependencyBaseModel

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

DependencyBaseModel

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

DependencyBaseModel

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

DependencyBaseModel

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

DependencyBaseModel

Returns true if this model has uncommitted changes for the provided field.
remove( silentfalse )
DependencyBaseModel

Removes this record from all stores (and in a tree structure, also from its parent if it has one).
revertChanges( )
DependencyBaseModel

Reverts changes in this back to their original values.
set( field, value, silentfalse )
DependencyBaseModel
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
setAsync( field, value, silentfalse )
: Promise

ASYNC
DependencyBaseModel
Set value for the specified field(s), triggering engine calculations immediately. See Model#set() for arguments. *
```
dependency.set('from', 2);
// dependency.fromEvent is not yet up to date

await dependency.setAsync('from', 2);
// dependency.fromEvent is up to date
```

setData( )

internal

DependencyBaseModel

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
DependencyBaseModel

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

DependencyBaseModel

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

DependencyBaseModel

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

DependencyBaseModel

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

private
DependencyBaseModel

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

toJSON( )

: Object

DependencyBaseModel

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

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

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
DependencyBaseModel

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
DependencyBaseModel

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

ADVANCED
DependencyBaseModel

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

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
DependencyBaseModel

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
DependencyBaseModel

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

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

ADVANCED
DependencyBaseModel

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

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

DependencyBaseModel

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.
instanceMeta( instanceOrId )

private
DependencyBaseModel

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
DependencyBaseModel

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

internal
DependencyBaseModel

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
DependencyBaseModel

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
DependencyBaseModel

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

DependencyBaseModel

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
DependencyBaseModel

Recalculates the value of a calculated field
syncId( value )

private
DependencyBaseModel

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

private
DependencyBaseModel

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

TreeNode

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

TreeNode

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

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

TreeNode

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

TreeNode

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

TreeNode

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

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

TreeNode

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

TreeNode

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

TreeNode

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

internal
TreeNode

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

TreeNode

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

TreeNode

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

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

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

TreeNode

Traverses child nodes recursively while fn returns true
getRelationConfig( name )
: Object

private
DependencyBaseModel

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

private
DependencyBaseModel

Initializes/updates a single relation.
initRelations( )

private
DependencyBaseModel

Initializes model relations. Called from store when adding a record.
clear( )

private
TreeNode

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

private
TreeNode

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

SchedulerPro/model/DependencyModel.js

DependencyModel

Fields and references

Async resolving of references

See also

Fields

Configs

Properties

Resolving a value from an owner

Value Merging

Config Options

Default Value

Functions

Source path

Inheritance tree4

Mixins4

Contents