• Public
  • Public/Protected
  • All

Class Meta<ValueT, ContextT>

The base class for identifiers. It contains only "meta" properties that describes "abstract" identifier. The Field class inherit from this class.

To understand the difference between the "abstract" identifier and the "specific" identifier, imagine a set of instances of the same entity class. Lets say that class has a field "name". All of those instances each will have different "specific" identifiers for the field "name".

In the same time, some properties are common for all "specific" identifiers, like equality, lazy etc. Such properties, that does not change between every "specific" identifier we will call "meta" properties.

This class has 2 generic arguments - ValueT and ContextT. The 1st one defines the type of the identifier's value. The 2nd - the identifier's computation context (synchronous of generator).

Type parameters





The type of the effects that can be "yielded" from the calculation function


lazy: boolean = false

Whether this identifier is lazy (true) or strict (false).

Lazy identifiers are calculated on-demand (when read from graph or used by another identifiers).

Strict identifiers will be calculated on read or during the commit call.


level: Levels

Level of the identifier. This attribute is supposed to be defined on the prototype level only.


name: any = undefined

The name of the identifiers. Not an id, does not imply uniqueness.


sync: boolean

Whether this identifier is sync (true) or generator-based (false). Default value is true. This attribute is supposed to be defined on the prototype level only.



  • calculation(this: this["CalcContextT"], Y: CalculationContext<this["YieldT"]>): Contexts<ValueT, this["YieldT"]>[ContextT]
  • The calculation function of the identifier. Its returning value has a generic type, that is converted to a specific type, based on the generic attribute ContextT.

    This function will receive a single argument - current calculation context (effects handler).

    When using generators, there's no need to use this handler - one can "yield" the value directly, using the yield construct.


    class Author extends Entity.mix(Base) {
        firstName       : string
        lastName        : string
        fullName        : string
        * calculateFullName () : ChronoIterator<string> {
            return (yield this.$.firstName) + ' ' + (yield this.$.lastName)
        calculateFullName (Y) : string {
            return Y(this.$.firstName) + ' ' + Y(this.$.lastName)


    Returns Contexts<ValueT, this["YieldT"]>[ContextT]


  • equality(v1: ValueT, v2: ValueT): boolean
  • The equality check of the identifier. By default is performed with ===.


    • v1: ValueT

      First value

    • v2: ValueT

      Second value

    Returns boolean


  • initialize<T>(props?: Partial<T>): void
  • This method applies its 1st argument (if any) to the current instance using Object.assign().

    Supposed to be overridden in the subclasses to customize the instance creation process.

    Type parameters


    • Optional props: Partial<T>

    Returns void

Static new

  • new<T>(this: T, props?: Partial<InstanceType<T>>): InstanceType<T>
  • This is a type-safe static constructor method, accepting a single argument, with the object, corresponding to the class properties. It will generate a compilation error, if unknown property is provided.

    For example:

    class MyClass extends Base {
        prop     : string
    const instance : MyClass = MyClass.new({ prop : 'prop', wrong : 11 })

    will produce:

    TS2345: Argument of type '{ prop: string; wrong: number; }' is not assignable to parameter of type 'Partial<MyClass>'.
    Object literal may only specify known properties, and 'wrong' does not exist in type 'Partial<MyClass>'

    The only thing this constructor does is create an instance and call the initialize method on it, forwarding the first argument. The customization of instance is supposed to be performed in that method.

    Type parameters


    • this: T
    • Optional props: Partial<InstanceType<T>>

    Returns InstanceType<T>

Generated using TypeDoc