StateType

Defines the shadowing behavior for a property. f.lux uses StateType instances to configure Shader instances that are then used to proxy the store's state using shadow properties.

Property subclasses usually expose a type'class variable to specify their default shadowing behavior. Thetypeclass variable should be a getter property and is typically attached to the class using theStateType.defineType()`` function.

Example of defining a type class variable:

StateType.defineType(TodoRootProperty, type => {
‌    type.initialState({})                           // empty object initial state
‌        .autoshadowOff                          // do not shadow state values without explicit definitions
‌        .properties({                           // define sub-properties (just one in this case)
‌            todos: TodoCollection.type,     // 'todos' is a collection property
‌        })
‌        .readonly                               // prevent reassigning the 'todos' collection (paranoia)
‌        .typeName("TodoRootProperty");          // useful for certain diagnostic situations
});

Shadowing behavior may be customized by setting the following StateType values:

• autoshadow - shadow implicit state properties using default f.lux property types (default=true)
• defaults - specifies default values for an object's initial state. A default value is applied when the initial state for this property is 'undefined'. (default=undefined)
• element type - StateType used for shadowing each sub-property, such as elements in an array or properties of an object. (default=null)
• jit properties - dynamically extends the 'properties' based on the property's state through a callback function (experimental)
• implementation class - ShadowImpl subclass used to back shadow state property (default=null)
• initial state - the initial property value. The store's state will take precedence and this value is used when the store's state is undefined for the specific property. (default=undefined)
• managed type - StateType instance used by CollectionProperty to specify the property type for each model contained in the collection. Other collection types could utilize the same mechanism. (default=null)
• properties - literal object with name/value pairs where name is the sub-property name and the value is a StateType instance describing the property shadowing behavior (default={})
• shadow class - Shadow subclass used to represent a shadow state property. Built-in implementation classes set a default so only need to set when want to customize parent type default. (default=null)

Methods/properties used when setting up a StateType description:

• addProperty(name, type) - add a single property type where 'name' is the sub-property name and value is a StateType. Consider using StateType.properties() instead.
• autoshadow - turn on auto-shadowing (default)
• autoshadowOff - turn off auto-shadowing
• default(state) - used with ObjectProperty and MapProperty sub-properties to set defaults for values. The default value is only applied if the initial state for this property is undefined. Example usage:

  stateType.properties({
  ‌    name: PrimitiveProperty.type.default(null),
  })
  

• elementType(type) - StateType for shadowing each sub-property. Regularly used with IndexedProperty and ArrayProperty. Used with ObjectProperty and MapProperty when each value is the same type such as in a dictionary.
• jitProperties(callback) - Sets a callback used for dynamically extending properties definition. Callback signature is 'callback(state, parentProperty)' and returns object with name/value pairs where name is the sub-property name and the value is a StateType instance describing the property shadowing behavior. (advanced feature)
• implementationClass(cls) - sets the ShadowImpl subclass to be used for backing the shadow state (should not be needed)
• initialState(state) - value suitable for the property type: boolean, array, object,...
• managedType(type) - StateType for shading managed properties (used with CollectionProperty) Example usage:

  stateType.managedType(TodoProperty.type)
  

• properties(propTypes) - add multiple properties using a literal object with property-name/StateType key/value pairs Example usage:

  stateType.properties({
  ‌    completed: PrimitiveProperty.type.initialState(false),
  ‌    created: PrimitiveProperty.type.readonly,
  ‌    desc: PrimitiveProperty.type,
  ‌    id: PrimitiveProperty.type.readonly,
  })
  

• readonly - set property to readonly
• readonlyOff - set property to read/write (default unless parent property has set readonly to true since readonly property cascades through the state tree)
• typeName(name) - set a label for the type. Useful for debugging situations where shadowing is not acting as expected. Example usage:

  const root = store.shadow;
  const rootProperty = root.$$();
  
  console.log(rootProperty.typeName());
  console.log(rootProperty.stateType().getTypeName());
  

Instances of this class are rarely directly created and instead are created using the defineType static functions of each built-in property class.