Class ObservableItem<P>

Description

The Item extensions is designed to form the structure of the object, solve the problem of application architecture, dependency injection and inversion of control.

Features:

  • cast to type properties
  • DI
  • IoC

Example

import * as collection from '@biorate/collection';
const { embed, singletone } = collection;
const BindedSymbol = Symbol('Binded');

@singletone()
class Binded {
  public hello = 'world!';
}

class Nested extends collection.Item {
  @embed(Nested.Map) public map: Map<any, any> = null;
  @embed(Nested.Set) public itemSet: Set<any> = null;
  @embed(BindedSymbol) public binded: Binded = null;
}

class Item extends collection.Item {
  @embed(Item.Int) public int: number = null;
  @embed(Item.Float) public float: number = null;
  @embed(Item.String) public string: string = null;
  @embed(Item.Bool) public bool: boolean = null;
  @embed(Item.Date) public date: Date = null;
  @embed(Item.Array) public array: number[] = null;
  @embed(Item.Object) public object: Record<string, any> = null;
  @embed(Item.Json) public json: Record<string, any> = null;
  @embed(Nested) public nested: Nested = null;
  @embed(BindedSymbol) public binded: Binded = null;
}

Item.bind(BindedSymbol, Binded);

const data = {
  int: 1,
  float: 1.1,
  string: 'test',
  bool: true,
  date: new Date(),
  array: [1, 2, 3],
  object: { a: 1, b: 2 },
  json: '{"test": 1}',
  nested: {
    map: [
      [1, 'a'],
      [2, 'b'],
    ],
    itemSet: [1, 2, 3],
  },
};

const item = new Item();

item.initialize(data);

console.log(item);
  // Item {
  //   int: 1,
  //   float: 1.1,
  //   string: 'test',
  //   bool: true,
  //   date: 2021-05-19T06:42:26.049Z,
  //   array: [ 1, 2, 3 ],
  //   object: { a: 1, b: 2 },
  //   json: { test: 1 },
  //   nested: Nested {
  //     map: Map { 1 => 'a', 2 => 'b' },
  //     itemSet: Set { 1, 2, 3 },
  //     binded: Binded { hello: 'world!' }
  //   }
  // }

console.log(item.binded === item.nested.binded); // true

Type Parameters

  • P = {
        parent?: any;
    }

Hierarchy

  • Item<P>
    • ObservableItem

Constructors

constructor

Properties

[_callbacks] Array Bool Date Float Int Json Luxon Map Object Set String bindings

Accessors

parent

Methods

[_defineClass] [_getType] [_observe] [_setData] [_setType] [_validate] initialize set subscribe unsubscribe bind

Constructors

constructor

  • Type Parameters

    • P = {
          parent?: any;
      }

    Parameters

    • data: Record<string, any> = null

      data object

    • parent: P = null

      parent item

    Returns ObservableItem<P>

    Example

    import * as collection from '@biorate/collection';

    class Item extends collection.Item {
      @embed(Item.Int) public id: number = null;
      @embed(Item.String) public title: string = null;
    }

    const item = new Item().initialize({ id: 1, title: 'one' });

Properties

[_callbacks]

[_callbacks]: Set<((...args) => void)> = ...

Type declaration

    • (...args): void

    • Parameters

      • Rest ...args: any[]
        Rest

      Returns void

Description

Callbacks storage

Static Readonly Array

Array: symbol = Types.Array

Description

cast to Array type symbol

Static Readonly Bool

Bool: symbol = Types.Bool

Description

cast to boolean type symbol

Static Readonly Date

Date: symbol = Types.Date

Description

cast to Date type symbol

Static Readonly Float

Float: symbol = Types.Float

Description

cast to float type symbol

Static Readonly Int

Int: symbol = Types.Int

Description

cast to int type symbol

Static Readonly Json

Json: symbol = Types.Json

Description

cast to JSON type symbol

Static Readonly Luxon

Luxon: symbol = Types.Luxon

Description

cast to Luxon type symbol

Static Readonly Map

Map: symbol = Types.Map

Description

cast to Map type symbol

Static Readonly Object

Object: symbol = Types.Object

Description

cast to Object type symbol

Static Readonly Set

Set: symbol = Types.Set

Description

cast to Set type symbol

Static Readonly String

String: symbol = Types.String

Description

cast to string type symbol

Static Readonly bindings

bindings: Map<string | symbol | Function, Function> = ...

Description

Binding map, for IoC pattern realization

Accessors

parent

Methods

[_defineClass]

  • [_defineClass](data, field, Class): void

  • Parameters

    • data: Record<string, any>

      data object

    • field: string

      object field

    • Class: (new (...args) => any)

      Instance class

        • new (...args): any

        • Parameters

          • Rest ...args: any[]
            Rest

          Returns any

    Returns void

    Description

    Instantiate and initialize class

[_getType]

[_observe]

  • [_observe](object, callback): void

  • Parameters

    • object: Record<string, any>
    • callback: ((data) => void)
        • (data): void

        • Parameters

          • data: Record<string, any>

          Returns void

    Returns void

    Description

    Make structure - observable, catch error if it already observable

[_setData]

[_setType]

[_validate]

initialize

set

  • Parameters

    • data: Record<string, any>

      data object

    Returns ObservableItem<P>

    Description

    Change data values

    Example

    import * as collection from '@biorate/collection';

    class Item extends collection.Item {
      @embed(Nested.Int) public int: number = null;
      @embed(Nested.String) public string: string = null;
    }

    const item = new Item().initialize({ int: 1, string: 'test' }});
    item.set({ int: 2, string: 'hello' }});
    console.log(item); // Item { int: 2, string: 'hello' }

subscribe

unsubscribe

Static bind

  • Parameters

    • key: string | symbol | Function

      dependency identifier

    • val: Function

      dependency Class

    Returns Map<string | symbol | Function, Function>

    Description

    Bind string, symbol, or Class to Class

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc