Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface ModelApi<TProps>

Type parameters

  • TProps: {} = {}

Hierarchy

  • Notifier<TProps>
  • Watchable<TProps>
  • Slicable<TProps>
    • ModelApi

Index

Properties

Methods

Properties

$call

$call: Call

call the method using model as method context

Readonly $model

$model: Model<TProps>

Readonly $props

$props: TProps

Methods

$batch

  • $batch(updater: (model: Model<TProps>) => void, lazy?: boolean): void

$data

  • $data(): Data<TProps>

$dirty

  • $dirty(): boolean
  • $dirty(prop: keyof TProps): boolean

$extend

  • $extend(): Model<TProps>
  • $extend<TNewModel>(builder: (base: Base<TProps>) => TNewModel): Model<TNewModel>
  • $extend<TNewModel>(props: TNewModel): Model<TNewModel>
  • $extend<TResult, TNewProps>(props: TNewProps, selector: (props: TProps) => TResult, mode?: ConcurrentMode): Model<TResult & TNewProps>

  • clone to new model

    Returns Model<TProps>

  • extend current model using child props builder. The builder retrieves base utils.

    base(); // return all base model props
    base('method', arg1, arg2, ...); // call base method with specified args

    Type parameters

    • TNewModel: {}

    Parameters

    • builder: (base: Base<TProps>) => TNewModel
        • (base: Base<TProps>): TNewModel

        • Parameters

          • base: Base<TProps>

          Returns TNewModel

    Returns Model<TNewModel>

  • extend current model. This overload is usually for Javascript version or the child model does not contain any prop/method accessing to base model

    Type parameters

    • TNewModel: {}

    Parameters

    • props: TNewModel

    Returns Model<TNewModel>

  • Type parameters

    • TResult: Record<string, any>

    • TNewProps: Record<string, any>

    Parameters

    • props: TNewProps
    • selector: (props: TProps) => TResult
        • (props: TProps): TResult

        • Parameters

          • props: TProps

          Returns TResult

    • Optional mode: ConcurrentMode

    Returns Model<TResult & TNewProps>

$get

  • $get<T>(prop: keyof TProps, state: State<T>): undefined | T

  • get state of specified prop

    Type parameters

    • T

    Parameters

    • prop: keyof TProps
    • state: State<T>

    Returns undefined | T

$hydrate

  • $hydrate(data: TProps): void

  • set the model data with hydrated data, if the model is already changed before, no hydration made

    Parameters

    • data: TProps

    Returns void

$init

$invalid

  • $invalid(): boolean
  • $invalid(prop: keyof TProps): any
  • $invalid(prop: keyof TProps, invalid: any): void

$listen

  • $listen(listener: VoidFunction): VoidFunction
  • $listen(prop: keyof TProps, listener: VoidFunction): VoidFunction
  • $listen(props: keyof TProps[], listener: VoidFunction): VoidFunction

  • Register listener to listen model props changed event

    Parameters

    • listener: VoidFunction

    Returns VoidFunction

  • Register listener to listen model props changed event. The listener will be called when specified prop is changged

    Parameters

    • prop: keyof TProps
    • listener: VoidFunction

    Returns VoidFunction

  • Register listener to listen model props changed event. The listener will be called when some of specified props are changged

    Parameters

    • props: keyof TProps[]
    • listener: VoidFunction

    Returns VoidFunction

$lock

  • $lock(): VoidFunction

$memo

  • $memo<TResult>(key: string, fn: () => TResult, deps?: any[]): TResult
  • $memo<TResult>(fn: () => TResult, deps?: any[]): TResult

  • Type parameters

    • TResult

    Parameters

    • key: string
    • fn: () => TResult
        • (): TResult

        • Returns TResult

    • Optional deps: any[]

    Returns TResult

  • Type parameters

    • TResult

    Parameters

    • fn: () => TResult
        • (): TResult

        • Returns TResult

    • Optional deps: any[]

    Returns TResult

$merge

  • $merge(props: Partial<TProps>, lazy?: boolean): void

  • Assign specified props to the model. Change event will be triggered once all props are assigned

    Parameters

    • props: Partial<TProps>
    • Optional lazy: boolean

    Returns void

$observe

  • $observe(observer: Observer): VoidFunction

$prop

  • $prop(prop: keyof TProps): Accessor<TProps[keyof TProps], TProps>

$reset

  • $reset(hardReset?: boolean): void

  • Reset all props of the model to initial values if hardReset = true, all listeners will be removed

    Parameters

    • Optional hardReset: boolean

    Returns void

$set

  • $set<T>(prop: keyof TProps, state: State<T>, value: T): void

  • change state of specified prop, when state value changed, model._onXXXStateChange called

    Type parameters

    • T

    Parameters

    • prop: keyof TProps
    • state: State<T>
    • value: T

    Returns void

$silent

  • $silent(): VoidFunction

$slice

  • $slice<TResult>(selector: (props: TProps) => TResult): ModelSlice<TResult>

  • Type parameters

    • TResult: Record<string, any>

    Parameters

    • selector: (props: TProps) => TResult
        • (props: TProps): TResult

        • Parameters

          • props: TProps

          Returns TResult

    Returns ModelSlice<TResult>

$sync

  • $sync<TModel>(model: TModel, selector: TModel extends Model<T> ? (props: T) => void | Partial<TProps> : (props: { [ key in string | number | symbol]: TModel[key] }) => void | Partial<TProps>, mode?: ConcurrentMode): VoidFunction

  • listen change from multiple models and call selector to retrieve an update

    Type parameters

    • TModel: {}

    Parameters

    • model: TModel
    • selector: TModel extends Model<T> ? (props: T) => void | Partial<TProps> : (props: { [ key in string | number | symbol]: TModel[key] }) => void | Partial<TProps>
    • Optional mode: ConcurrentMode

    Returns VoidFunction

$touched

  • $touched(): boolean
  • $touched(prop: keyof TProps): boolean

$wait

  • $wait(): Promise<void>
  • $wait<TResult>(selector: (model: TProps) => TResult, compareFn?: Comparer<TResult>): Promise<TResult>

  • wait model's next change

    Returns Promise<void>

  • wait model's next change

    Type parameters

    • TResult

    Parameters

    • selector: (model: TProps) => TResult
        • (model: TProps): TResult

        • Parameters

          • model: TProps

          Returns TResult

    • Optional compareFn: Comparer<TResult>

    Returns Promise<TResult>

$watch

  • $watch<TResult>(selector: (model: TProps) => TResult, callback: (result: TResult) => void, compareFn: Comparer<TResult>): VoidFunction
  • $watch<TResult>(selector: (model: TProps) => TResult, callback: (result: TResult) => void, options: WatchOptions<TResult>): VoidFunction

  • Type parameters

    • TResult

    Parameters

    • selector: (model: TProps) => TResult
        • (model: TProps): TResult

        • Parameters

          • model: TProps

          Returns TResult

    • callback: (result: TResult) => void
        • (result: TResult): void

        • Parameters

          • result: TResult

          Returns void

    • compareFn: Comparer<TResult>

    Returns VoidFunction

  • The callback will be called when selected value which is returned from the selector is changed.

    Type parameters

    • TResult

    Parameters

    • selector: (model: TProps) => TResult
        • (model: TProps): TResult

        • Parameters

          • model: TProps

          Returns TResult

    • callback: (result: TResult) => void
        • (result: TResult): void

        • Parameters

          • result: TResult

          Returns void

    • options: WatchOptions<TResult>

    Returns VoidFunction

$when

$wrap

toJSON

  • toJSON(): TProps

Generated using TypeDoc