ShadowImpl

Maps the getter and setter (if appropriate) onto the parent property.

Gets the next model state for the property. This value is used for performing property updates through the update() function.

Calls to update() trigger an update through the dispatcher upon which the new object will be mapped and the store informed of the change.

Schedules an UPDATE action with the store. On action execution, the new property will be generated and returned to the store.

Replace the value of this property. This will result in this property tree being recreated.

Note: This value will be used directly (not copied) so ensure the state is not altered.

Invoked during defineProperty() to define children properties marked for automount

Prevents all children from being able to obtain model in update() callbacks. Update callbacks should invoke this method when they perform wholesale

Prevents this property and descendents from providing a model to update() callbacks.

The update() method invokes this method when the callback returns a different object than the one passed into the callback.

Subclasses should implement this method in such a way as not to trigger a mapping.

Gets the implementation objects managed by this property.

Creates a deep clone of the current property state.

Create a copy of the internals during reshadowing when the property has not changed during the update process but some descendant has been modified.

Merges a new state into this property by using the 'state' parameter to set default values, ie it will not overwrite any existing values. Useful when model objects arrive from external sources, such as an asyncrhonous save or a websocket based update.

Maps all child properties onto this property using Object.defineProperty().

Invoked on shadow getter access to obtain the get value.

The default implementation returns the shadow.

Invoked on shadow property assignment to perform the replacement f.lux action.

The default implementation is to assign the new value with no checking.

Intended for use by update() and replaying actions.

Helpful debugging utility that returns the path joined by '.'. The root node will return the word 'root' for the path.

Gets a child implementation matching a property name or undefined if no such property exists.

Gets if the property has an child properties (not whether child properties are supported).

Gets if an update has occurred directly to this property.

Marks property and ancestors as invalid. This means this property or one of its children has been updated. The invalid flag is set to the earliest timestamp when this property or one of its children was changed.

Parameters: childImpl - the child implementation triggering this call or undefined if this implementation started the invalidation process source - the shadow implementation that triggered the invalidation

Gets if the property represents live data.

Gets if defineChildProperties() has been invoked.

Gets if this property type reprsents a primitive javascript type.

Gets whether the property value supports calls to update().

Gets if this property or one of its child properties has pending updates. Returns true if there are no pending updates.

Gets the keys/indices for this property.

Implementation note: Subclasses should implement this method in such a way as not to trigger a mapping.

Merges a new state into this property. Useful when model objects arrive from external sources, such as an asyncrhonous save or a websocket based update.

Gets the name after all model updates are performed.

Gets the model as it will be once all pending changes are recorded with the store. This must not be altered.

Marks this property as obsolete. Once marked obsolete a property may not interact with the store. A property becomes obsolete after it's value or ancestor's value has changed and the update process has completed.

This method does not affect subproperties.

Marks the entire subtree as inactive, aka dead.

Hook for when this property is no longer represented in the system state.

Property has just been reshadowed.

Hook for when this property is no longer represented in the system state due to a state update - not a replacement.

Gets an array with the property names/indices from the root to this property.

Invoked by reshadow() function for invalid parent property implementations when the directly managed state did not change.

Calls the onReshadow(prev) method to provide subclasses an oppotunity to setup for futher action after a parent change.

Sets the readonly flag which will prevent a 'set' function being set in defineProeprty().

Note: this method must be called before defineProperty() is invoked or it will have no affect.

Creates shadow properties for root properties and sets this property on the parent property for non-root properties.

Note: This method is called by shadowProperty() and reshadow() functions.

Gets the shader needed to recreate the shadow property for the state.

Gets the user facing property represented by this implementation object.

Helpful debugging utility that returns the path joined by '.'. The root node will return the word 'root' for the path.

Transfers the nextName to the name attribute.

Gets a compact version of this internal's state. It does NOT provide a JSON representation of the model state. The actual Property.toJSON() method returns the model JSON representation.

Makes changes to the next property state. The callback should be pure (no side affects) but that is not a requirement. The callback must be of the form:

(state) => return { nextState, replace }

where: state - the next property state nextState - the state following the callback replace - boolean for whether nextState replaces the current value. The implication of true is that this property and all of it's children will not be able to make future changes to the model.

To understand the reasoning behind the replace flag consider the following example:

const model = { a: { b: { c: 1 } } } const oldB = model.a.b

model.a.b = "foo" oldB.c = 5

model.a.b.c === undefined

Thus, oldB.c may change oldB'c property 'c' to 5 but model.a.b is still "foo".

Changes the name this property will have after updates. This is used when moving properties around in the model, such as when splice is used on an array. The nextName() method will return the property name for after updates are applied.

Note: this method does not have any side effects beyond setting the _nextName instance variable. Subclasss will need to perform any book keeping associated with sub-properties.

Marks this property as dead. Once marked obsolete a property may not accept further updates. A property is updated when the state changes but not a wholesale replacement or a descendents's value has changed and the update process has completed.

This method does not affect subproperties.

Gets if shadow property is allowing state updates.

Invokes a callback once all pending changes have occurred. The callback should have the form:

callback(property, implementation)

where the property and implementation arguments are the latest version if they still exist.

This method is safe to call on a dead property.

Invoked by the shadowing process to invoke appropriate Property life-cycle methods. The method name is a reflection that shadow state tree invocation chain for willShadow() occurs when the Store is going to shadow that state.